home *** CD-ROM | disk | FTP | other *** search
/ Computer Shopper 139 / dpcs0999.iso / Web / CFserver / data1.cab / Java / netscape / util / FormattingSerializer.class (.txt) < prev    next >
Encoding:
Java Class File  |  1999-04-12  |  6.6 KB  |  487 lines
  1. package netscape.util;
  2.  
  3. import java.io.ByteArrayInputStream;
  4. import java.io.ByteArrayOutputStream;
  5. import java.io.FilterOutputStream;
  6. import java.io.IOException;
  7. import java.io.OutputStream;
  8.  
  9. public class FormattingSerializer extends Serializer {
  10.    private final int MAX_SIZE_FOR_SMALL_EXPRESSION = 80;
  11.    private int indentationLength = 4;
  12.    private int tabLevel = 0;
  13.    private int nextCharIndex = 0;
  14.  
  15.    public FormattingSerializer(OutputStream var1) {
  16.       super(var1);
  17.    }
  18.  
  19.    public void setIndentationLength(int var1) {
  20.       this.indentationLength = var1;
  21.    }
  22.  
  23.    public int indentationLength() {
  24.       return this.indentationLength;
  25.    }
  26.  
  27.    public void writeComment(String var1, boolean var2) throws IOException {
  28.       int var3 = var1.length();
  29.       byte var4;
  30.       if (var2) {
  31.          var4 = 7;
  32.       } else {
  33.          var4 = 4;
  34.       }
  35.  
  36.       if (var3 + var4 <= 80 - this.nextCharIndex && var1.indexOf(10) == -1) {
  37.          if (var2) {
  38.             this.writeCommentCharacter(47);
  39.             this.writeCommentCharacter(42);
  40.             this.writeCommentCharacter(32);
  41.          } else {
  42.             this.writeCommentCharacter(47);
  43.             this.writeCommentCharacter(47);
  44.             this.writeCommentCharacter(32);
  45.          }
  46.  
  47.          for(int var7 = 0; var7 < var3; ++var7) {
  48.             this.writeCommentCharacter(var1.charAt(var7));
  49.          }
  50.  
  51.          if (var2) {
  52.             this.writeCommentCharacter(32);
  53.             this.writeCommentCharacter(42);
  54.             this.writeCommentCharacter(47);
  55.             this.writeCommentCharacter(10);
  56.          } else {
  57.             this.writeCommentCharacter(10);
  58.          }
  59.       } else {
  60.          if (var2) {
  61.             this.writeCommentCharacter(47);
  62.             this.writeCommentCharacter(42);
  63.             this.writeCommentCharacter(10);
  64.             this.writeCommentCharacter(32);
  65.             this.writeCommentCharacter(42);
  66.             this.writeCommentCharacter(32);
  67.          } else {
  68.             this.writeCommentCharacter(47);
  69.             this.writeCommentCharacter(47);
  70.             this.writeCommentCharacter(32);
  71.          }
  72.  
  73.          for(int var6 = 0; var6 < var3; ++var6) {
  74.             char var5 = var1.charAt(var6);
  75.             if (var5 == '\n') {
  76.                this.writeCommentCharacter(10);
  77.                if (var2) {
  78.                   this.writeCommentCharacter(32);
  79.                   this.writeCommentCharacter(42);
  80.                   this.writeCommentCharacter(32);
  81.                } else {
  82.                   this.writeCommentCharacter(47);
  83.                   this.writeCommentCharacter(47);
  84.                   this.writeCommentCharacter(32);
  85.                }
  86.             } else {
  87.                this.writeCommentCharacter(var5);
  88.             }
  89.          }
  90.  
  91.          if (var2) {
  92.             this.writeCommentCharacter(10);
  93.             this.writeCommentCharacter(32);
  94.             this.writeCommentCharacter(42);
  95.             this.writeCommentCharacter(47);
  96.             this.writeCommentCharacter(10);
  97.          } else {
  98.             this.writeCommentCharacter(10);
  99.          }
  100.       }
  101.    }
  102.  
  103.    private final void increaseTabLevel() {
  104.       ++this.tabLevel;
  105.    }
  106.  
  107.    private final void decreaseTabLevel() {
  108.       --this.tabLevel;
  109.    }
  110.  
  111.    private final void insertNewLine() throws IOException {
  112.       this.writeCharacter(10);
  113.       int var1 = 0;
  114.  
  115.       for(int var2 = this.tabLevel * this.indentationLength(); var1 < var2; ++var1) {
  116.          this.writeCharacter(32);
  117.       }
  118.  
  119.    }
  120.  
  121.    private final void writeCharacter(int var1) throws IOException {
  122.       super.writeOutput(var1);
  123.       if (var1 == 10) {
  124.          this.nextCharIndex = 0;
  125.       } else {
  126.          ++this.nextCharIndex;
  127.       }
  128.    }
  129.  
  130.    private final void writeCommentCharacter(int var1) throws IOException {
  131.       if (var1 >= 32 && var1 < 127) {
  132.          this.writeCharacter(var1);
  133.       } else {
  134.          switch (var1) {
  135.             case 9:
  136.             case 10:
  137.             case 13:
  138.                this.writeCharacter(var1);
  139.             default:
  140.          }
  141.       }
  142.    }
  143.  
  144.    private final int serializedStringFitsIn(String var1, int var2) {
  145.       if (var1 != null && var1.length() != 0) {
  146.          int var4;
  147.          if ((var4 = var1.length()) > var2) {
  148.             return var4;
  149.          } else {
  150.             int var5;
  151.             if (((Serializer)this).stringRequiresQuotes(var1)) {
  152.                var5 = 2;
  153.             } else {
  154.                var5 = 0;
  155.             }
  156.  
  157.             for(int var3 = 0; var3 < var4; ++var3) {
  158.                char var6 = var1.charAt(var3);
  159.                if (var6 < 255) {
  160.                   if (var6 >= '#' && var6 <= '~' && var6 != '\\') {
  161.                      ++var5;
  162.                   } else {
  163.                      switch (var6) {
  164.                         case '\t':
  165.                         case '\n':
  166.                         case '\r':
  167.                         case '"':
  168.                         case '\\':
  169.                            var5 += 2;
  170.                            break;
  171.                         case ' ':
  172.                         case '!':
  173.                            ++var5;
  174.                            break;
  175.                         default:
  176.                            var5 += 4;
  177.                      }
  178.                   }
  179.                } else {
  180.                   var5 += 6;
  181.                }
  182.  
  183.                if (var5 > var2) {
  184.                   return var5;
  185.                }
  186.             }
  187.  
  188.             return var5;
  189.          }
  190.       } else {
  191.          return 2;
  192.       }
  193.    }
  194.  
  195.    private final int serializedHashtableFitsIn(Hashtable var1, int var2) {
  196.       int var9 = 2;
  197.       Enumeration var4 = var1.keys();
  198.  
  199.       while(var4.hasMoreElements()) {
  200.          Object var5 = var4.nextElement();
  201.          ++var9;
  202.          var9 += this.serializedObjectFitsIn(var5, var2 - var9);
  203.          if (var9 > var2) {
  204.             return var9;
  205.          }
  206.  
  207.          int var8 = var9 + 3;
  208.          var9 = var8 + this.serializedObjectFitsIn(var1.get(var5), var2 - var8);
  209.          ++var9;
  210.          if (var9 > var2) {
  211.             return var9;
  212.          }
  213.       }
  214.  
  215.       return var9;
  216.    }
  217.  
  218.    private final int serializedArrayFitsIn(Object[] var1, int var2) {
  219.       int var3 = 3;
  220.       int var4 = 0;
  221.  
  222.       for(int var5 = var1.length; var4 < var5; ++var4) {
  223.          ++var3;
  224.          var3 += this.serializedObjectFitsIn(var1[var4], var2 - var3);
  225.          if (var3 > var2) {
  226.             return var3;
  227.          }
  228.  
  229.          if (var4 < var5 - 1) {
  230.             ++var3;
  231.          }
  232.       }
  233.  
  234.       return var3;
  235.    }
  236.  
  237.    private final int serializedVectorFitsIn(Vector var1, int var2) {
  238.       int var3 = 3;
  239.       int var4 = 0;
  240.  
  241.       for(int var5 = var1.count(); var4 < var5; ++var4) {
  242.          ++var3;
  243.          var3 += this.serializedObjectFitsIn(var1.elementAt(var4), var2 - var3);
  244.          if (var3 > var2) {
  245.             return var3;
  246.          }
  247.  
  248.          if (var4 < var5 - 1) {
  249.             ++var3;
  250.          }
  251.       }
  252.  
  253.       return var3;
  254.    }
  255.  
  256.    private final int serializedNullFitsIn() {
  257.       return 1;
  258.    }
  259.  
  260.    private final int serializedObjectFitsIn(Object var1, int var2) {
  261.       if (var1 instanceof String) {
  262.          return this.serializedStringFitsIn((String)var1, var2);
  263.       } else if (var1 instanceof Hashtable) {
  264.          return this.serializedHashtableFitsIn((Hashtable)var1, var2);
  265.       } else if (var1 instanceof Object[]) {
  266.          return this.serializedArrayFitsIn(var1, var2);
  267.       } else if (var1 instanceof Vector) {
  268.          return this.serializedVectorFitsIn((Vector)var1, var2);
  269.       } else {
  270.          return var1 == null ? this.serializedNullFitsIn() : this.serializedStringFitsIn(var1.toString(), var2);
  271.       }
  272.    }
  273.  
  274.    private final boolean canFitExpressionOnLine(Object var1) {
  275.       int var2 = 80 - this.nextCharIndex;
  276.       return this.serializedObjectFitsIn(var1, var2) <= var2;
  277.    }
  278.  
  279.    private final void formatVector(Vector var1) throws IOException {
  280.       int var2 = var1.count();
  281.       if (this.canFitExpressionOnLine(var1)) {
  282.          this.writeCharacter(40);
  283.  
  284.          for(int var4 = 0; var4 < var2; ++var4) {
  285.             this.writeCharacter(32);
  286.             this.formatObject(var1.elementAt(var4));
  287.             if (var4 < var2 - 1) {
  288.                this.writeCharacter(44);
  289.             }
  290.          }
  291.  
  292.          this.writeCharacter(32);
  293.          this.writeCharacter(41);
  294.       } else {
  295.          this.writeCharacter(40);
  296.          this.increaseTabLevel();
  297.  
  298.          for(int var3 = 0; var3 < var2; ++var3) {
  299.             this.insertNewLine();
  300.             this.formatObject(var1.elementAt(var3));
  301.             if (var3 < var2 - 1) {
  302.                this.writeCharacter(44);
  303.             }
  304.          }
  305.  
  306.          this.decreaseTabLevel();
  307.          this.insertNewLine();
  308.          this.writeCharacter(41);
  309.       }
  310.    }
  311.  
  312.    private final void formatArray(Object[] var1) throws IOException {
  313.       int var2 = var1.length;
  314.       if (this.canFitExpressionOnLine(var1)) {
  315.          this.writeCharacter(91);
  316.  
  317.          for(int var4 = 0; var4 < var2; ++var4) {
  318.             this.writeCharacter(32);
  319.             this.formatObject(var1[var4]);
  320.             if (var4 < var2 - 1) {
  321.                this.writeCharacter(44);
  322.             }
  323.          }
  324.  
  325.          this.writeCharacter(32);
  326.          this.writeCharacter(93);
  327.       } else {
  328.          this.writeCharacter(91);
  329.          this.increaseTabLevel();
  330.  
  331.          for(int var3 = 0; var3 < var2; ++var3) {
  332.             this.insertNewLine();
  333.             this.formatObject(var1[var3]);
  334.             if (var3 < var2 - 1) {
  335.                this.writeCharacter(44);
  336.             }
  337.          }
  338.  
  339.          this.decreaseTabLevel();
  340.          this.insertNewLine();
  341.          this.writeCharacter(93);
  342.       }
  343.    }
  344.  
  345.    private final void formatHashtable(Hashtable var1) throws IOException {
  346.       Enumeration var3 = var1.keys();
  347.       int var9 = 0;
  348.       int var10 = 0;
  349.       int var2 = var1.count();
  350.       String[] var6 = new String[var2];
  351.       Object[] var8 = new Object[var2];
  352.       var3 = var1.keys();
  353.  
  354.       for(int var11 = 0; var11 < var2; ++var11) {
  355.          Object var7 = var3.nextElement();
  356.          if (var7 instanceof String) {
  357.             var6[var10++] = (String)var7;
  358.          } else {
  359.             var8[var9++] = var7;
  360.          }
  361.       }
  362.  
  363.       if (var10 > 0) {
  364.          Sort.sortStrings(var6, 0, var10, true, false);
  365.          System.arraycopy(var6, 0, var8, var9, var10);
  366.       }
  367.  
  368.       if (this.canFitExpressionOnLine(var1)) {
  369.          this.writeCharacter(123);
  370.  
  371.          for(int var16 = 0; var16 < var2; ++var16) {
  372.             this.writeCharacter(32);
  373.             Object var13 = var8[var16];
  374.             Object var14 = var1.get(var13);
  375.             this.formatObject(var13);
  376.             this.writeCharacter(32);
  377.             this.writeCharacter(61);
  378.             this.writeCharacter(32);
  379.             this.formatObject(var14);
  380.             this.writeCharacter(59);
  381.          }
  382.  
  383.          this.writeCharacter(125);
  384.       } else {
  385.          this.writeCharacter(123);
  386.          this.increaseTabLevel();
  387.  
  388.          for(int var15 = 0; var15 < var2; ++var15) {
  389.             Object var4 = var8[var15];
  390.             Object var5 = var1.get(var4);
  391.             this.insertNewLine();
  392.             this.formatObject(var4);
  393.             this.writeCharacter(32);
  394.             this.writeCharacter(61);
  395.             this.writeCharacter(32);
  396.             this.formatObject(var5);
  397.             this.writeCharacter(59);
  398.          }
  399.  
  400.          this.decreaseTabLevel();
  401.          this.insertNewLine();
  402.          this.writeCharacter(125);
  403.       }
  404.    }
  405.  
  406.    private final void formatObject(Object var1) throws IOException {
  407.       if (var1 instanceof String) {
  408.          ((Serializer)this).serializeString((String)var1);
  409.       } else if (var1 instanceof Hashtable) {
  410.          this.formatHashtable((Hashtable)var1);
  411.       } else if (var1 instanceof Object[]) {
  412.          this.formatArray(var1);
  413.       } else if (var1 instanceof Vector) {
  414.          this.formatVector((Vector)var1);
  415.       } else if (var1 == null) {
  416.          ((Serializer)this).serializeNull();
  417.       } else {
  418.          ((Serializer)this).serializeString(var1.toString());
  419.       }
  420.    }
  421.  
  422.    public void writeObject(Object var1) throws IOException {
  423.       this.formatObject(var1);
  424.    }
  425.  
  426.    public static String serializeObject(Object var0) {
  427.       Object var1 = null;
  428.       String var6;
  429.       if (var0 == null) {
  430.          var6 = null;
  431.       } else {
  432.          ByteArrayOutputStream var2 = new ByteArrayOutputStream(256);
  433.          FormattingSerializer var3 = new FormattingSerializer(var2);
  434.  
  435.          try {
  436.             var3.writeObject(var0);
  437.             ((Serializer)var3).flush();
  438.          } catch (IOException var5) {
  439.          }
  440.  
  441.          var6 = var2.toString();
  442.  
  443.          try {
  444.             ((FilterOutputStream)var3).close();
  445.             ((OutputStream)var2).close();
  446.          } catch (IOException var4) {
  447.          }
  448.  
  449.          Object var7 = null;
  450.          Object var8 = null;
  451.       }
  452.  
  453.       return var6;
  454.    }
  455.  
  456.    public static byte[] formatBytes(byte[] var0) {
  457.       ByteArrayInputStream var1 = new ByteArrayInputStream(var0);
  458.       Object var2 = Deserializer.readObject(var1);
  459.       if (var2 != null) {
  460.          ByteArrayOutputStream var3 = new ByteArrayOutputStream();
  461.          FormattingSerializer var4 = new FormattingSerializer(var3);
  462.  
  463.          try {
  464.             var4.writeObject(var2);
  465.             ((Serializer)var4).flush();
  466.          } catch (IOException var5) {
  467.             return null;
  468.          }
  469.  
  470.          return var3.toByteArray();
  471.       } else {
  472.          return null;
  473.       }
  474.    }
  475.  
  476.    public static boolean writeObject(OutputStream var0, Object var1) {
  477.       try {
  478.          FormattingSerializer var2 = new FormattingSerializer(var0);
  479.          var2.writeObject(var1);
  480.          ((Serializer)var2).flush();
  481.          return true;
  482.       } catch (IOException var3) {
  483.          return false;
  484.       }
  485.    }
  486. }
  487.