home *** CD-ROM | disk | FTP | other *** search
/ PC Online 1998 January / PCO0198.ISO / browser / net_linx / java40.jar / netscape / util / PrimitiveCoder.class (.txt) < prev    next >
Encoding:
Java Class File  |  1997-11-03  |  4.7 KB  |  200 lines
  1. package netscape.util;
  2.  
  3. class PrimitiveCoder implements ExternalCoder {
  4.    byte type;
  5.  
  6.    PrimitiveCoder(byte var1) {
  7.       this.type = var1;
  8.    }
  9.  
  10.    public Object newInstance(String var1) throws CodingException {
  11.       return null;
  12.    }
  13.  
  14.    static String classNameForType(byte var0) {
  15.       switch (var0) {
  16.          case 0:
  17.             return "java.lang.Boolean";
  18.          case 1:
  19.             return "[Z";
  20.          case 2:
  21.             return "java.lang.Character";
  22.          case 3:
  23.             return "[C";
  24.          case 4:
  25.             return "java.lang.Byte";
  26.          case 5:
  27.             return "[B";
  28.          case 6:
  29.             return "java.lang.Short";
  30.          case 7:
  31.             return "[S";
  32.          case 8:
  33.             return "java.lang.Integer";
  34.          case 9:
  35.             return "[I";
  36.          case 10:
  37.             return "java.lang.Long";
  38.          case 11:
  39.             return "[J";
  40.          case 12:
  41.             return "java.lang.Float";
  42.          case 13:
  43.             return "[F";
  44.          case 14:
  45.             return "java.lang.Double";
  46.          case 15:
  47.             return "[D";
  48.          case 16:
  49.             return "java.lang.String";
  50.          case 17:
  51.             return "[Ljava.lang.String;";
  52.          case 18:
  53.          case 19:
  54.          default:
  55.             throw new InconsistencyException("Non-primitive type!");
  56.       }
  57.    }
  58.  
  59.    String className() {
  60.       return classNameForType(this.type);
  61.    }
  62.  
  63.    public void describeClassInfo(Object var1, ClassInfo var2) {
  64.       var2.addClass(classNameForType(this.type), 1);
  65.       var2.addField("value", this.type);
  66.    }
  67.  
  68.    public void encode(Object var1, Encoder var2) throws CodingException {
  69.       switch (this.type) {
  70.          case 0:
  71.             var2.encodeBoolean("value", (Boolean)var1);
  72.             return;
  73.          case 1:
  74.             var2.encodeBooleanArray("value", (boolean[])var1, 0, ((boolean[])var1).length);
  75.             return;
  76.          case 2:
  77.             var2.encodeChar("value", (Character)var1);
  78.             return;
  79.          case 3:
  80.             var2.encodeCharArray("value", (char[])var1, 0, ((char[])var1).length);
  81.             return;
  82.          case 4:
  83.             throw new CodingException("java.lang.Byte not supported");
  84.          case 5:
  85.             var2.encodeByteArray("value", (byte[])var1, 0, ((byte[])var1).length);
  86.             return;
  87.          case 6:
  88.             throw new CodingException("java.lang.Short not supported");
  89.          case 7:
  90.             var2.encodeShortArray("value", (short[])var1, 0, ((short[])var1).length);
  91.             return;
  92.          case 8:
  93.             var2.encodeInt("value", (Integer)var1);
  94.             return;
  95.          case 9:
  96.             var2.encodeIntArray("value", (int[])var1, 0, ((int[])var1).length);
  97.             return;
  98.          case 10:
  99.             var2.encodeLong("value", (Long)var1);
  100.             return;
  101.          case 11:
  102.             var2.encodeLongArray("value", (long[])var1, 0, ((long[])var1).length);
  103.             return;
  104.          case 12:
  105.             var2.encodeFloat("value", (Float)var1);
  106.             return;
  107.          case 13:
  108.             var2.encodeFloatArray("value", (float[])var1, 0, ((float[])var1).length);
  109.             return;
  110.          case 14:
  111.             var2.encodeDouble("value", (Double)var1);
  112.             return;
  113.          case 15:
  114.             var2.encodeDoubleArray("value", (double[])var1, 0, ((double[])var1).length);
  115.             return;
  116.          case 16:
  117.             var2.encodeString("value", (String)var1);
  118.             return;
  119.          case 17:
  120.             var2.encodeStringArray("value", (String[])var1, 0, ((String[])var1).length);
  121.             return;
  122.          case 18:
  123.          case 19:
  124.          default:
  125.             throw new CodingException("Non-primitive type!");
  126.       }
  127.    }
  128.  
  129.    public void decode(Object var1, Decoder var2) throws CodingException {
  130.       Object var3;
  131.       switch (this.type) {
  132.          case 0:
  133.             if (var2.decodeBoolean("value")) {
  134.                var3 = Boolean.TRUE;
  135.             } else {
  136.                var3 = Boolean.FALSE;
  137.             }
  138.             break;
  139.          case 1:
  140.             var3 = var2.decodeBooleanArray("value");
  141.             break;
  142.          case 2:
  143.             var3 = new Character(var2.decodeChar("value"));
  144.             break;
  145.          case 3:
  146.             var3 = var2.decodeCharArray("value");
  147.             break;
  148.          case 4:
  149.             throw new CodingException("java.lang.Byte not supported");
  150.          case 5:
  151.             var3 = var2.decodeByteArray("value");
  152.             break;
  153.          case 6:
  154.             throw new CodingException("java.lang.Short not supported");
  155.          case 7:
  156.             var3 = var2.decodeShortArray("value");
  157.             break;
  158.          case 8:
  159.             var3 = new Integer(var2.decodeInt("value"));
  160.             break;
  161.          case 9:
  162.             var3 = var2.decodeIntArray("value");
  163.             break;
  164.          case 10:
  165.             var3 = new Long(var2.decodeLong("value"));
  166.             break;
  167.          case 11:
  168.             var3 = var2.decodeLongArray("value");
  169.             break;
  170.          case 12:
  171.             var3 = new Float(var2.decodeFloat("value"));
  172.             break;
  173.          case 13:
  174.             var3 = var2.decodeFloatArray("value");
  175.             break;
  176.          case 14:
  177.             var3 = new Double(var2.decodeDouble("value"));
  178.             break;
  179.          case 15:
  180.             var3 = var2.decodeDoubleArray("value");
  181.             break;
  182.          case 16:
  183.             var3 = var2.decodeString("value");
  184.             break;
  185.          case 17:
  186.             var3 = var2.decodeStringArray("value");
  187.             break;
  188.          case 18:
  189.          case 19:
  190.          default:
  191.             throw new CodingException("Non-primitive type!");
  192.       }
  193.  
  194.       var2.replaceObject(var3);
  195.    }
  196.  
  197.    public void finishDecoding(Object var1) throws CodingException {
  198.    }
  199. }
  200.