git.gag.com Git - fw/altos/blob - altoslib/AltosJson.java

   1 /*
   2  * Copyright © 2016 Keith Packard <keithp@keithp.com>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  17  */
  18
  19 package org.altusmetrum.altoslib_14;
  20
  21 import java.io.*;
  22 import java.util.*;
  23 import java.text.*;
  24 import java.lang.*;
  25 import java.lang.reflect.*;
  26
  27 class JsonUtil {
  28         Writer quote(Writer writer, String a) throws IOException {
  29                 writer.append("\"");
  30                 for (int i = 0; i < a.length(); i++) {
  31                         char c = a.charAt(i);
  32
  33                         switch (c) {
  34                         case '"':
  35                         case '\\':
  36                                 writer.append('\\').append(c);
  37                                 break;
  38                         case '\n':
  39                                 writer.append("\\n");
  40                                 break;
  41                         default:
  42                                 writer.append(c);
  43                                 break;
  44                         }
  45                 }
  46                 writer.append("\"");
  47                 return writer;
  48         }
  49
  50         Writer append(Writer result, AltosJson value, int indent, boolean pretty) throws IOException {
  51                 value.append(result, indent, pretty);
  52                 return result;
  53         }
  54
  55         Writer append(Writer result, String string) throws IOException {
  56                 result.append(string);
  57                 return result;
  58         }
  59
  60         Writer indent(Writer result, int indent) throws IOException {
  61                 result.append("\n");
  62                 for (int i = 0; i < indent; i++)
  63                         result.append("\t");
  64                 return result;
  65         }
  66
  67         NumberFormat _nf_json;
  68
  69         NumberFormat nf_json() {
  70                 if (_nf_json == null) {
  71                         DecimalFormat nf = (DecimalFormat) NumberFormat.getNumberInstance(Locale.ROOT);
  72                         nf.setParseIntegerOnly(false);
  73                         nf.setGroupingUsed(false);
  74                         nf.setMaximumFractionDigits(17);
  75                         nf.setMinimumFractionDigits(0);
  76                         nf.setMinimumIntegerDigits(1);
  77                         nf.setDecimalSeparatorAlwaysShown(false);
  78                         _nf_json = nf;
  79                 }
  80                 return _nf_json;
  81         }
  82 }
  83
  84 class JsonHash extends JsonUtil {
  85         Hashtable<String,AltosJson> hash;
  86
  87         void append_hash(Writer result, int indent, boolean pretty) throws IOException {
  88                 boolean         first = true;
  89
  90                 result.append("{");
  91
  92                 ArrayList<String> key_list = new ArrayList<String>(hash.keySet());
  93
  94                 Collections.sort(key_list, new Comparator<String>() {
  95                                 @Override
  96                                 public int compare(String a, String b) { return a.compareTo(b); }
  97                         });
  98
  99                 for (String key : key_list) {
 100                         AltosJson       value = hash.get(key);
 101
 102                         if (!first)
 103                                 result.append(",");
 104                         first = false;
 105                         if (pretty)
 106                                 indent(result, indent+1);
 107                         quote(result, key);
 108                         append(result, ": ");
 109                         append(result, value, indent+1, pretty);
 110                 }
 111                 if (pretty)
 112                         indent(result, indent);
 113                 append(result, "}");
 114         }
 115
 116         void put(String key, AltosJson value) {
 117                 hash.put(key, value);
 118         }
 119
 120         AltosJson get(String key) {
 121                 return hash.get(key);
 122         }
 123
 124         JsonHash() {
 125                 hash = new Hashtable<String,AltosJson>();
 126         }
 127 }
 128
 129 class JsonArray extends JsonUtil {
 130         ArrayList<AltosJson> array;
 131
 132         void append_array(Writer result, int indent, boolean pretty) throws IOException {
 133                 boolean first = true;
 134
 135                 append(result, "[");
 136                 for (int i = 0; i < array.size(); i++) {
 137                         AltosJson       value = array.get(i);
 138
 139                         if (!first)
 140                                 append(result, ",");
 141                         first = false;
 142                         if (pretty)
 143                                 indent(result, indent+1);
 144                         append(result, value, indent+1, pretty);
 145                 }
 146                 if (pretty)
 147                         indent(result, indent);
 148                 append(result, "]");
 149         }
 150
 151         void put(int index, AltosJson value) {
 152                 if (index >= array.size())
 153                         array.add(index, value);
 154                 else
 155                         array.set(index, value);
 156         }
 157
 158         AltosJson get(int index) {
 159                 if (index < 0 || index > array.size())
 160                         return null;
 161                 return array.get(index);
 162         }
 163
 164         int size() {
 165                 return array.size();
 166         }
 167
 168         JsonArray() {
 169                 array = new ArrayList<AltosJson>();
 170         }
 171 }
 172
 173 class JsonToken {
 174         double  dval;
 175         long    lval;
 176         String  sval;
 177         boolean bval;
 178         int     token;
 179
 180         static final int _string = 0;
 181         static final int _double = 1;
 182         static final int _long = 2;
 183         static final int _boolean = 3;
 184         static final int _oc = 4;
 185         static final int _cc = 5;
 186         static final int _os = 6;
 187         static final int _cs = 7;
 188         static final int _comma = 8;
 189         static final int _colon = 9;
 190         static final int _end = 10;
 191         static final int _error = 11;
 192         static final int _none = 12;
 193
 194         static String token_name(int token) {
 195                 switch (token) {
 196                 case _string:
 197                         return "string";
 198                 case _double:
 199                         return "number";
 200                 case _long:
 201                         return "number";
 202                 case _boolean:
 203                         return "boolean";
 204                 case _oc:
 205                         return "{";
 206                 case _cc:
 207                         return "}";
 208                 case _os:
 209                         return "[";
 210                 case _cs:
 211                         return "]";
 212                 case _comma:
 213                         return ",";
 214                 case _colon:
 215                         return ":";
 216                 case _end:
 217                         return "<EOF>";
 218                 case _error:
 219                         return "<ERROR>";
 220                 default:
 221                         return "<UNKNOWN>";
 222                 }
 223         }
 224
 225         String token_name() {
 226                 return token_name(token);
 227         }
 228
 229         JsonToken(int token) {
 230                 this.token = token;
 231         }
 232
 233         JsonToken(int token, boolean bval) {
 234                 this.token = token;
 235                 this.bval = bval;
 236         }
 237
 238         JsonToken(int token, double dval) {
 239                 this.token = token;
 240                 this.dval = dval;
 241         }
 242
 243         JsonToken(int token, long lval) {
 244                 this.token = token;
 245                 this.lval = lval;
 246         }
 247
 248         JsonToken(int token, String sval) {
 249                 this.token = token;
 250                 this.sval = sval;
 251         }
 252
 253         JsonToken(int token, Writer bval) {
 254                 this(token, bval.toString());
 255         }
 256 }
 257
 258 /*
 259  * Lexer for json
 260  */
 261 class JsonLexer extends JsonUtil {
 262         InputStream             f;
 263         int                     line;
 264         int                     ungot = -2;
 265         StringBuffer            pending_token;
 266         private JsonToken       token;
 267
 268         static class keyword {
 269                 String          word;
 270                 JsonToken       token;
 271
 272                 JsonToken match(String value) {
 273                         if (word.equals(value))
 274                                 return token;
 275                         return null;
 276                 }
 277
 278                 keyword(String word, JsonToken token) {
 279                         this.word = word;
 280                         this.token = token;
 281                 }
 282         }
 283
 284         /* boolean values are the only keywords in json
 285          */
 286         static keyword[] keywords = {
 287                 new keyword("true", new JsonToken(JsonToken._boolean, true)),
 288                 new keyword("false", new JsonToken(JsonToken._boolean, false)),
 289                 new keyword("NegInfinity", new JsonToken(JsonToken._double, Double.NEGATIVE_INFINITY)),
 290                 new keyword("Infinity", new JsonToken(JsonToken._double, Double.POSITIVE_INFINITY)),
 291                 new keyword("NaN", new JsonToken(JsonToken._double, Double.NaN))
 292         };
 293
 294         static JsonToken keyword(String word) {
 295                 for (int i = 0; i < keywords.length; i++) {
 296                         JsonToken token = keywords[i].match(word);
 297                         if (token != null)
 298                                 return token;
 299                 }
 300                 return null;
 301         }
 302
 303         /* Get the next char (-1 for EOF) */
 304         int ch() throws IOException {
 305                 int c;
 306                 if (ungot != -2) {
 307                         c = ungot;
 308                         ungot = -2;
 309                 } else
 310                         c = f.read();
 311                 if (c != -1)
 312                         pending_token.append((char) c);
 313                 if (c == '\n')
 314                         ++line;
 315                 return c;
 316         }
 317
 318         void unch(int c) {
 319                 if (ungot != -2)
 320                         throw new IllegalArgumentException("ungot buffer full");
 321                 pending_token.deleteCharAt( pending_token.length()-1);
 322                 if (c == '\n')
 323                         --line;
 324                 ungot = c;
 325         }
 326
 327         String last_token_string() {
 328                 if (pending_token == null)
 329                         return null;
 330
 331                 return pending_token.toString();
 332         }
 333
 334         static boolean is_long_range(double d) {
 335                 return -9223372036854775808.0 <= d && d <= 9223372036854775807.0;
 336         }
 337
 338         JsonToken lex() {
 339                 pending_token = new StringBuffer();
 340
 341                 try {
 342                         for (;;) {
 343                                 int c = ch();
 344
 345                                 switch (c) {
 346                                 case -1:
 347                                         return new JsonToken(JsonToken._end);
 348                                 case '\n':
 349                                 case ' ':
 350                                 case '\t':
 351                                         continue;
 352                                 case '{':
 353                                         return new JsonToken(JsonToken._oc);
 354                                 case '}':
 355                                         return new JsonToken(JsonToken._cc);
 356                                 case '[':
 357                                         return new JsonToken(JsonToken._os);
 358                                 case ']':
 359                                         return new JsonToken(JsonToken._cs);
 360                                 case ',':
 361                                         return new JsonToken(JsonToken._comma);
 362                                 case ':':
 363                                         return new JsonToken(JsonToken._colon);
 364                                 case '0': case '1': case '2': case '3': case '4':
 365                                 case '5': case '6': case '7': case '8': case '9':
 366                                 case '.': case '-': case '+':
 367                                         StringBuffer dbuf = new StringBuffer();
 368                                         boolean is_double = false;
 369                                         while (Character.isDigit(c) || c == '.' || c == '+' || c == '-' || c == 'e' || c == 'E') {
 370                                                 if (c == '.' || c == 'E')
 371                                                         is_double = true;
 372                                                 dbuf.appendCodePoint(c);
 373                                                 c = ch();
 374                                         }
 375                                         unch(c);
 376                                         String dstr = dbuf.toString();
 377                                         double dval;
 378                                         try {
 379                                                 dval = nf_json().parse(dstr).doubleValue();
 380                                         } catch (ParseException pe) {
 381                                                 return new JsonToken(JsonToken._error, dstr);
 382                                         }
 383                                         if (is_double || !is_long_range(dval))
 384                                                 return new JsonToken(JsonToken._double, dval);
 385                                         else {
 386                                                 long lval = Long.parseLong(dstr);
 387                                                 return new JsonToken(JsonToken._long, lval);
 388                                         }
 389                                 case '"':
 390                                         Writer bval = new StringWriter();
 391                                         for (;;) {
 392                                                 c = ch();
 393                                                 if (c == '"')
 394                                                         break;
 395                                                 if (c == '\\') {
 396                                                         c = ch();
 397                                                         switch (c) {
 398                                                         case 'n':
 399                                                                 c = '\n';
 400                                                                 break;
 401                                                         case 't':
 402                                                                 c = '\t';
 403                                                                 break;
 404                                                         default:
 405                                                                 break;
 406                                                         }
 407                                                 }
 408                                                 bval.write(c);
 409                                         }
 410                                         return new JsonToken(JsonToken._string, bval);
 411                                 default:
 412                                         if (Character.isLetter(c)) {
 413                                                 StringBuffer tbuf = new StringBuffer();
 414                                                 do {
 415                                                         tbuf.appendCodePoint(c);
 416                                                         c = ch();
 417                                                 } while (Character.isLetter(c));
 418                                                 unch(c);
 419                                                 JsonToken token = keyword(tbuf.toString());
 420                                                 if (token != null)
 421                                                         return token;
 422                                         }
 423                                         break;
 424                                 }
 425                         }
 426                 } catch (IOException ie) {
 427                         return new JsonToken(JsonToken._error, "<EIO>");
 428                 }
 429         }
 430
 431         void next() {
 432                 token = null;
 433         }
 434
 435         JsonToken token() {
 436                 if (token == null)
 437                         token = lex();
 438                 return token;
 439         }
 440
 441         JsonToken expect(int e) {
 442                 JsonToken t = token();
 443                 if (t.token != e)
 444                         throw new IllegalArgumentException(String.format("got \"%s\" while expecting \"%s\"",
 445                                                                          token.token_name(),
 446                                                                          JsonToken.token_name(e)));
 447                 next();
 448                 return t;
 449         }
 450
 451         JsonLexer(String s) {
 452                 f = new AltosStringInputStream(s);
 453                 line = 1;
 454                 token = null;
 455         }
 456
 457         JsonLexer(InputStream f) {
 458                 this.f = f;
 459                 line = 1;
 460                 token = null;
 461         }
 462 }
 463
 464 /*
 465  * Parse a json string into a AltosJson object
 466  */
 467 class JsonParse {
 468         JsonLexer       lexer;
 469
 470         void parse_error(String format, Object ... arguments) {
 471                 throw new IllegalArgumentException(String.format("line %d: JSON parse error %s\n",
 472                                                                  lexer.line,
 473                                                                  String.format(format, arguments)));
 474         }
 475
 476         /* Hashes are { string: value ... } */
 477         JsonHash hash() {
 478                 JsonHash        hash = new JsonHash();
 479
 480                 /* skip the open brace */
 481                 lexer.next();
 482                 for (;;) {
 483                         /* Allow for empty hashes */
 484                         if (lexer.token().token == JsonToken._cc) {
 485                                 lexer.next();
 486                                 return hash;
 487                         }
 488
 489                         /* string : value */
 490                         String key = lexer.expect(JsonToken._string).sval;
 491                         lexer.expect(JsonToken._colon);
 492                         AltosJson value = value();
 493                         hash.put(key, value);
 494
 495                         switch (lexer.token().token) {
 496                         case JsonToken._comma:
 497                                 lexer.next();
 498                                 break;
 499                         case JsonToken._cc:
 500                                 lexer.next();
 501                                 return hash;
 502                         default:
 503                                 parse_error("got %s expect \",\" or \"}\"", lexer.token().token_name());
 504                                 return null;
 505                         }
 506                 }
 507         }
 508
 509         /* Arrays are [ value ... ] */
 510         JsonArray array() {
 511                 JsonArray       array = new JsonArray();
 512
 513                 lexer.next();
 514                 for (int i = 0;; i++) {
 515                         /* Allow for empty arrays */
 516                         if (lexer.token().token == JsonToken._cs) {
 517                                 lexer.next();
 518                                 return array;
 519                         }
 520
 521                         AltosJson value = value();
 522                         array.put(i, value);
 523                         switch (lexer.token().token) {
 524                         case JsonToken._comma:
 525                                 lexer.next();
 526                                 break;
 527                         case JsonToken._cs:
 528                                 lexer.next();
 529                                 return array;
 530                         default:
 531                                 parse_error("got %s expect \",\" or \"]\"", lexer.token().token_name());
 532                                 return null;
 533                         }
 534                 }
 535         }
 536
 537         /* Json is a simple LL language; one token is sufficient to
 538          * identify the next object in the input
 539          */
 540         AltosJson value() {
 541                 switch (lexer.token().token) {
 542                 case JsonToken._oc:
 543                         return new AltosJson(hash());
 544                 case JsonToken._os:
 545                         return new AltosJson(array());
 546                 case JsonToken._double:
 547                         double dval = lexer.token().dval;
 548                         lexer.next();
 549                         return new AltosJson(dval);
 550                 case JsonToken._long:
 551                         long lval = lexer.token().lval;
 552                         lexer.next();
 553                         return new AltosJson(lval);
 554                 case JsonToken._string:
 555                         String sval = lexer.token().sval;
 556                         lexer.next();
 557                         return new AltosJson(sval);
 558                 case JsonToken._boolean:
 559                         boolean bval = lexer.token().bval;
 560                         lexer.next();
 561                         return new AltosJson(bval);
 562                 default:
 563                         parse_error("Unexpected token \"%s\"", lexer.token().token_name());
 564                 }
 565                 return null;
 566         }
 567
 568         AltosJson parse() {
 569                 lexer.next();
 570                 return value();
 571         }
 572
 573         JsonParse(String s) {
 574                 lexer = new JsonLexer(s);
 575         }
 576
 577         JsonParse(InputStream f) {
 578                 lexer = new JsonLexer(f);
 579         }
 580 }
 581
 582 public class AltosJson extends JsonUtil {
 583         private static final int        type_none = 0;
 584         private static final int        type_hash = 1;
 585         private static final int        type_array = 2;
 586         private static final int        type_double = 3;
 587         private static final int        type_long = 4;
 588         private static final int        type_string = 5;
 589         private static final int        type_boolean = 6;
 590
 591         private int             type;
 592
 593         private JsonHash        hash;
 594         private JsonArray       array;
 595         private double          d_number;
 596         private long            l_number;
 597         private String          string;
 598         private boolean         bool;
 599
 600         /* Generate string representation of the value
 601          */
 602         Writer append(Writer result, int indent, boolean pretty) throws IOException {
 603                 switch (type) {
 604                 case type_hash:
 605                         hash.append_hash(result, indent, pretty);
 606                         break;
 607                 case type_array:
 608                         array.append_array(result, indent, pretty);
 609                         break;
 610                 case type_double:
 611                         if (Double.isInfinite(d_number)) {
 612                                 if (d_number < 0)
 613                                         result.append("NegInfinity");
 614                                 else
 615                                         result.append("Infinity");
 616                         } else if (Double.isNaN(d_number)) {
 617                                 result.append("NaN");
 618                         } else {
 619                                 String dval = nf_json().format(d_number);
 620                                 if (dval.equals("-0"))
 621                                         dval = "0";
 622                                 result.append(dval);
 623                         }
 624                         break;
 625                 case type_long:
 626                         result.append(Long.valueOf(l_number).toString());
 627                         break;
 628                 case type_string:
 629                         quote(result, string);
 630                         break;
 631                 case type_boolean:
 632                         result.append(bool ? "true" : "false");
 633                         break;
 634                 }
 635                 return result;
 636         }
 637
 638         private String toString(int indent, boolean pretty) {
 639                 try {
 640                         Writer result = new StringWriter();
 641                         append(result, indent, pretty);
 642                         return result.toString();
 643                 } catch (Exception e) {
 644                         return null;
 645                 }
 646         }
 647
 648         public String toString() {
 649                 return toString(0, false);
 650         }
 651
 652         public String toPrettyString() {
 653                 return toString(0, true);
 654         }
 655
 656         public void write(Writer w, int indent, boolean pretty) throws IOException {
 657                 append(w, indent, pretty);
 658         }
 659
 660         public void write(Writer w) throws IOException {
 661                 write(w, 0, true);
 662         }
 663
 664         /* Parse string representation to a value
 665          */
 666
 667         public static AltosJson fromString(String string) {
 668                 JsonParse       parse = new JsonParse(string);
 669                 try {
 670                         return parse.parse();
 671                 } catch (IllegalArgumentException ie) {
 672                         System.out.printf("json:\n%s\n%s\n", string, ie.getMessage());
 673                         return null;
 674                 }
 675         }
 676
 677         public static AltosJson fromInputStream(InputStream f) {
 678                 JsonParse       parse = new JsonParse(f);
 679                 try {
 680                         return parse.parse();
 681                 } catch (IllegalArgumentException ie) {
 682                         System.out.printf("json:\n%s\n", ie.getMessage());
 683                         return null;
 684                 }
 685         }
 686
 687         /* Accessor functions
 688          */
 689         private boolean assert_type(boolean setting, int type, int other_type, String error) {
 690                 if (setting && this.type == type_none) {
 691                         this.type = type;
 692                         return false;
 693                 }
 694                 if (this.type != type && this.type != other_type)
 695                         throw new IllegalArgumentException(error);
 696                 return true;
 697         }
 698
 699         private boolean assert_type(boolean setting, int type, String error) {
 700                 return assert_type(setting, type, type, error);
 701         }
 702
 703         private void assert_hash(boolean setting) {
 704                 if (!assert_type(setting, type_hash, "not a hash"))
 705                         hash = new JsonHash();
 706         }
 707
 708         private void assert_array(boolean setting) {
 709                 if (!assert_type(setting, type_array, "not an array"))
 710                         array = new JsonArray();
 711         }
 712
 713         private void assert_number() {
 714                 assert_type(false, type_double, type_long, "not a number");
 715         }
 716
 717         private void assert_double() {
 718                 assert_type(true, type_double, type_long, "not a number");
 719         }
 720
 721         private void assert_long() {
 722                 assert_type(true, type_long, type_double, "not a number");
 723         }
 724
 725         private void assert_string(boolean setting) {
 726                 assert_type(setting, type_string, "not a string");
 727         }
 728
 729         private void assert_boolean(boolean setting) {
 730                 assert_type(setting, type_boolean, "not a boolean");
 731         }
 732
 733         /* Primitive accessors
 734          */
 735         public double number() {
 736                 assert_number();
 737                 if (type == type_double)
 738                         return d_number;
 739                 else
 740                         return (double) l_number;
 741         }
 742
 743         public long l_number() {
 744                 assert_number();
 745                 if (type == type_double)
 746                         return (long) d_number;
 747                 else
 748                         return l_number;
 749         }
 750
 751         public String string() {
 752                 assert_string(false);
 753                 return string;
 754         }
 755
 756         public boolean bool() {
 757                 assert_boolean(false);
 758                 return bool;
 759         }
 760
 761         public AltosJson get(int index) {
 762                 assert_array(false);
 763                 return array.get(index);
 764         }
 765
 766         public AltosJson get(String key) {
 767                 assert_hash(false);
 768                 return hash.get(key);
 769         }
 770
 771         public int size() {
 772                 assert_array(false);
 773                 return array.size();
 774         }
 775
 776         /* Typed accessors with defaulting
 777          */
 778         public double get_double(String key, double def) {
 779                 AltosJson value = get(key);
 780                 if (value != null) {
 781                         return value.number();
 782                 }
 783                 return def;
 784         }
 785
 786         public long get_long(String key, long def) {
 787                 AltosJson value = get(key);
 788                 if (value != null)
 789                         return value.l_number();
 790                 return def;
 791         }
 792
 793         public int get_int(String key, int def) {
 794                 AltosJson value = get(key);
 795                 if (value != null)
 796                         return (int) value.l_number();
 797                 return def;
 798         }
 799
 800         public String get_string(String key, String def) {
 801                 AltosJson value = get(key);
 802                 if (value != null)
 803                         return value.string();
 804                 return def;
 805         }
 806
 807         public boolean get_boolean(String key, boolean def) {
 808                 AltosJson value = get(key);
 809                 if (value != null)
 810                         return value.bool();
 811                 return def;
 812         }
 813
 814         public double get_double(int index, double def) {
 815                 AltosJson value = get(index);
 816                 if (value != null)
 817                         return value.number();
 818                 return def;
 819         }
 820
 821         public long get_long(int index, long def) {
 822                 AltosJson value = get(index);
 823                 if (value != null)
 824                         return value.l_number();
 825                 return def;
 826         }
 827
 828         public int get_int(int index, int def) {
 829                 AltosJson value = get(index);
 830                 if (value != null)
 831                         return (int) value.l_number();
 832                 return def;
 833         }
 834
 835         public String get_string(int index, String def) {
 836                 AltosJson value = get(index);
 837                 if (value != null)
 838                         return value.string();
 839                 return def;
 840         }
 841
 842         public boolean get_boolean(int index, boolean def) {
 843                 AltosJson value = get(index);
 844                 if (value != null)
 845                         return value.bool();
 846                 return def;
 847         }
 848
 849         public double[] get_double_array(String key, double[] def) {
 850                 AltosJson value = get(key);
 851                 if (value != null) {
 852                         double[] ret = new double[value.size()];
 853                         for (int i = 0; i < value.size(); i++)
 854                                 ret[i] = value.get_double(i, def == null ? 0 : def[i]);
 855                         return ret;
 856                 }
 857                 return def;
 858         }
 859
 860         public int[] get_int_array(String key, int[] def) {
 861                 AltosJson value = get(key);
 862                 if (value != null) {
 863                         int[] ret = new int[value.size()];
 864                         for (int i = 0; i < value.size(); i++)
 865                                 ret[i] = value.get_int(i, def == null ? 0 : def[i]);
 866                         return ret;
 867                 }
 868                 return def;
 869         }
 870
 871         /* Array setter functions
 872          */
 873         public AltosJson put(int index, AltosJson value) {
 874                 assert_array(true);
 875                 array.put(index, value);
 876                 return value;
 877         }
 878
 879         public Object put(int index, Object value) {
 880                 assert_array(true);
 881                 if (value != null)
 882                         array.put(index, new AltosJson(value));
 883                 return value;
 884         }
 885
 886         public double put(int index, double value) {
 887                 assert_array(true);
 888                 array.put(index, new AltosJson(value));
 889                 return value;
 890         }
 891
 892         public AltosJson put(int index, double[] value) {
 893                 if (value != null) {
 894                         assert_array(true);
 895                         array.put(index, new AltosJson(value));
 896                 }
 897                 return this;
 898         }
 899
 900         public int[] put(int index, int[] value) {
 901                 if (value != null) {
 902                         assert_array(true);
 903                         array.put(index, new AltosJson(value));
 904                 }
 905                 return value;
 906         }
 907
 908         public String put(int index, String value) {
 909                 if (value != null) {
 910                         assert_array(true);
 911                         array.put(index, new AltosJson(value));
 912                 }
 913                 return value;
 914         }
 915
 916         public boolean put(int index, boolean value) {
 917                 assert_array(true);
 918                 array.put(index, new AltosJson(value));
 919                 return value;
 920         }
 921
 922         /* Hash setter functions
 923          */
 924         public AltosJson put(String key, AltosJson value) {
 925                 assert_hash(true);
 926                 hash.put(key, value);
 927                 return value;
 928         }
 929
 930         public Object put(String key, Object value) {
 931                 assert_hash(true);
 932                 if (value != null)
 933                         hash.put(key, new AltosJson(value));
 934                 return value;
 935         }
 936
 937         public double put(String key, double value) {
 938                 assert_hash(true);
 939                 hash.put(key, new AltosJson(value));
 940                 return value;
 941         }
 942
 943         public String put(String key, String value) {
 944                 if (value != null) {
 945                         assert_hash(true);
 946                         hash.put(key, new AltosJson(value));
 947                 }
 948                 return value;
 949         }
 950
 951         public boolean put(String key, boolean value) {
 952                 assert_hash(true);
 953                 hash.put(key, new AltosJson(value));
 954                 return value;
 955         }
 956
 957         public AltosJson[] put(String key, AltosJson[] value) {
 958                 if (value != null) {
 959                         assert_hash(true);
 960                         hash.put(key, new AltosJson(value));
 961                 }
 962                 return value;
 963         }
 964
 965         public double[] put(String key, double[] value) {
 966                 if (value != null) {
 967                         assert_hash(true);
 968                         hash.put(key, new AltosJson(value));
 969                 }
 970                 return value;
 971         }
 972
 973         public int[] put(String key, int[] value) {
 974                 if (value != null) {
 975                         assert_hash(true);
 976                         hash.put(key, new AltosJson(value));
 977                 }
 978                 return value;
 979         }
 980
 981         /* Primitive setter functions
 982          */
 983         public double put(double value) {
 984                 assert_double();
 985                 d_number = value;
 986                 return value;
 987         }
 988
 989         public byte put(byte value) {
 990                 assert_long();
 991                 l_number = value;
 992                 return value;
 993         }
 994
 995         public char put(char value) {
 996                 assert_long();
 997                 l_number = value;
 998                 return value;
 999         }
1000
1001         public int put(int value) {
1002                 assert_long();
1003                 l_number = value;
1004                 return value;
1005         }
1006
1007         public long put(long value) {
1008                 assert_long();
1009                 l_number = value;
1010                 return value;
1011         }
1012
1013         public String put(String value) {
1014                 assert_string(true);
1015                 string = value;
1016                 return value;
1017         }
1018
1019         public boolean put(boolean value) {
1020                 assert_boolean(true);
1021                 bool = value;
1022                 return value;
1023         }
1024
1025         private boolean isInnerClass(Class c) {
1026                 for (Field field : c.getDeclaredFields())
1027                         if (field.isSynthetic())
1028                                 return true;
1029                 return false;
1030         }
1031
1032         /* Construct an object of the specified class from the JSON
1033          * representation.
1034          *
1035          * This works as long as the structure is non-recursive, and
1036          * all inner classes are only members of their immediate outer
1037          * class
1038          */
1039         @SuppressWarnings("unchecked")
1040         private Object make(Class c, Class enclosing_class, Object enclosing_object) {
1041                 Object  ret;
1042                 if (c == Boolean.TYPE) {
1043                         ret = bool();
1044                 } else if (c == Byte.TYPE) {
1045                         ret = (Byte) (byte) l_number();
1046                 } else if (c == Character.TYPE) {
1047                         ret = (Character) (char) l_number();
1048                 } else if (c == Integer.TYPE) {
1049                         ret = (Integer) (int) l_number();
1050                 } else if (c == Long.TYPE) {
1051                         ret = l_number();
1052                 } else if (c == Double.TYPE) {
1053                         ret = number();
1054                 } else if (c == String.class) {
1055                         ret = string();
1056                 } else if (c.isArray()) {
1057                         assert_array(false);
1058
1059                         Class element_class = c.getComponentType();
1060                         if (element_class == Boolean.TYPE) {
1061                                 boolean[] array = (boolean[]) Array.newInstance(element_class, size());
1062                                 for (int i = 0; i < array.length; i++)
1063                                         array[i] = (Boolean) get(i).make(element_class);
1064                                 ret = array;
1065                         } else if (element_class == Byte.TYPE) {
1066                                 byte[] array = (byte[]) Array.newInstance(element_class, size());
1067                                 for (int i = 0; i < array.length; i++)
1068                                         array[i] = (Byte) get(i).make(element_class);
1069                                 ret = array;
1070                         } else if (element_class == Character.TYPE) {
1071                                 char[] array = (char[]) Array.newInstance(element_class, size());
1072                                 for (int i = 0; i < array.length; i++)
1073                                         array[i] = (Character) get(i).make(element_class);
1074                                 ret = array;
1075                         } else if (element_class == Integer.TYPE) {
1076                                 int[] array = (int[]) Array.newInstance(element_class, size());
1077                                 for (int i = 0; i < array.length; i++)
1078                                         array[i] = (Integer) get(i).make(element_class);
1079                                 ret = array;
1080                         } else if (element_class == Long.TYPE) {
1081                                 long[] array = (long[]) Array.newInstance(element_class, size());
1082                                 for (int i = 0; i < array.length; i++)
1083                                         array[i] = (Long) get(i).make(element_class);
1084                                 ret = array;
1085                         } else if (element_class == Double.TYPE) {
1086                                 double[] array = (double[]) Array.newInstance(element_class, size());
1087                                 for (int i = 0; i < array.length; i++)
1088                                         array[i] = (Double) get(i).make(element_class);
1089                                 ret = array;
1090                         } else {
1091                                 Object[] array = (Object[]) Array.newInstance(element_class, size());
1092                                 for (int i = 0; i < array.length; i++)
1093                                         array[i] = get(i).make(element_class);
1094                                 ret = array;
1095                         }
1096                 } else {
1097                         assert_hash(false);
1098                         Object object = null;
1099                         try {
1100                                 /* Inner classes have a hidden extra parameter
1101                                  * to the constructor. Assume that the enclosing object is
1102                                  * of the enclosing class and construct the object
1103                                  * based on that.
1104                                  */
1105                                 if (enclosing_class != null && isInnerClass(c)) {
1106                                         Constructor<?> ctor = ((Class<?>)c).getDeclaredConstructor((Class<?>) enclosing_class);
1107                                         object = ctor.newInstance(enclosing_object);
1108                                 } else {
1109                                         object = c.getDeclaredConstructor().newInstance();
1110                                 }
1111                                 for (; c != Object.class; c = c.getSuperclass()) {
1112                                         for (Field field : c.getDeclaredFields()) {
1113                                                 String  fieldName = field.getName();
1114                                                 Class   fieldClass = field.getType();
1115
1116                                                 if (Modifier.isStatic(field.getModifiers()))
1117                                                         continue;
1118                                                 if (field.isSynthetic())
1119                                                         continue;
1120                                                 try {
1121                                                         AltosJson json = get(fieldName);
1122                                                         if (json != null) {
1123                                                                 Object val = json.make(fieldClass, c, object);
1124                                                                 field.setAccessible(true);
1125                                                                 field.set(object, val);
1126                                                         }
1127                                                 } catch (IllegalAccessException ie) {
1128                                                         System.out.printf("%s:%s %s\n",
1129                                                                           c.getName(), fieldName, ie.toString());
1130                                                 }
1131                                         }
1132                                 }
1133                                 ret = object;
1134                         } catch (InvocationTargetException ie) {
1135                                 System.out.printf("%s: %s\n",
1136                                                   c.getName(), ie.toString());
1137                                 ret = null;
1138                         } catch (NoSuchMethodException ie) {
1139                                 System.out.printf("%s: %s\n",
1140                                                   c.getName(), ie.toString());
1141                                 ret = null;
1142                         } catch (InstantiationException ie) {
1143                                 System.out.printf("%s: %s\n",
1144                                                   c.getName(), ie.toString());
1145                                 ret = null;
1146                         } catch (IllegalAccessException ie) {
1147                                 System.out.printf("%s: %s\n",
1148                                                   c.getName(), ie.toString());
1149                                 ret = null;
1150                         }
1151                 }
1152                 return ret;
1153         }
1154
1155         /* This is the public API for the
1156          * above function which doesn't handle
1157          * inner classes
1158          */
1159         public Object make(Class c) {
1160                 return make(c, null, null);
1161         }
1162
1163         /* Constructors, one for each primitive type, String and Object */
1164         public AltosJson(boolean bool) {
1165                 type = type_boolean;
1166                 this.bool = bool;
1167         }
1168
1169         public AltosJson(byte number) {
1170                 type = type_long;
1171                 this.l_number = number;
1172         }
1173
1174         public AltosJson(char number) {
1175                 type = type_long;
1176                 this.l_number = number;
1177         }
1178
1179         public AltosJson(int number) {
1180                 type = type_long;
1181                 this.l_number = number;
1182         }
1183
1184         public AltosJson(long number) {
1185                 type = type_long;
1186                 this.l_number = number;
1187         }
1188
1189         public AltosJson(double number) {
1190                 type = type_double;
1191                 this.d_number = number;
1192         }
1193
1194         public AltosJson(String string) {
1195                 type = type_string;
1196                 this.string = string;
1197         }
1198
1199         public AltosJson(Object object) {
1200                 if (object instanceof Boolean) {
1201                         type = type_boolean;
1202                         bool = (Boolean) object;
1203                 } else if (object instanceof Byte) {
1204                         type = type_long;
1205                         l_number = (Byte) object;
1206                 } else if (object instanceof Character) {
1207                         type = type_long;
1208                         l_number = (Character) object;
1209                 } else if (object instanceof Integer) {
1210                         type = type_long;
1211                         l_number = (Integer) object;
1212                 } else if (object instanceof Long) {
1213                         type = type_long;
1214                         l_number = (Long) object;
1215                 } else if (object instanceof Double) {
1216                         type = type_double;
1217                         d_number = (Double) object;
1218                 } else if (object instanceof String) {
1219                         type = type_string;
1220                         string = (String) object;
1221                 } else if (object.getClass().isArray()) {
1222                         assert_array(true);
1223
1224                         Class component_class = object.getClass().getComponentType();
1225                         if (component_class == Boolean.TYPE) {
1226                                 boolean[] array = (boolean[]) object;
1227                                 for (int i = 0; i < array.length; i++)
1228                                         put(i, new AltosJson(array[i]));
1229                         } else if (component_class == Byte.TYPE) {
1230                                 byte[] array = (byte[]) object;
1231                                 for (int i = 0; i < array.length; i++)
1232                                         put(i, new AltosJson(array[i]));
1233                         } else if (component_class == Character.TYPE) {
1234                                 char[] array = (char[]) object;
1235                                 for (int i = 0; i < array.length; i++)
1236                                         put(i, new AltosJson(array[i]));
1237                         } else if (component_class == Integer.TYPE) {
1238                                 int[] array = (int[]) object;
1239                                 for (int i = 0; i < array.length; i++)
1240                                         put(i, new AltosJson(array[i]));
1241                         } else if (component_class == Long.TYPE) {
1242                                 long[] array = (long[]) object;
1243                                 for (int i = 0; i < array.length; i++)
1244                                         put(i, new AltosJson(array[i]));
1245                         } else if (component_class == Double.TYPE) {
1246                                 double[] array = (double[]) object;
1247                                 for (int i = 0; i < array.length; i++)
1248                                         put(i, new AltosJson(array[i]));
1249                         } else {
1250                                 Object[] array = (Object[]) object;
1251                                 for (int i = 0; i < array.length; i++)
1252                                         put(i, new AltosJson(array[i]));
1253                         }
1254                 } else {
1255                         assert_hash(true);
1256                         for (Class c = object.getClass(); c != Object.class; c = c.getSuperclass()) {
1257                                 for (Field field : c.getDeclaredFields()) {
1258                                         String  fieldName = field.getName();
1259
1260                                         /* XXX hack to allow fields to be not converted */
1261                                         if (fieldName.startsWith("__"))
1262                                                 continue;
1263
1264                                         /* Skip static fields */
1265                                         if (Modifier.isStatic(field.getModifiers()))
1266                                                 continue;
1267
1268                                         /* Skip synthetic fields. We're assuming
1269                                          * those are always an inner class reference
1270                                          * to the outer class object
1271                                          */
1272                                         if (field.isSynthetic())
1273                                                 continue;
1274                                         try {
1275                                                 /* We may need to force the field to be accessible if
1276                                                  * it is private
1277                                                  */
1278                                                 field.setAccessible(true);
1279                                                 Object val = field.get(object);
1280                                                 if (val != null) {
1281                                                         AltosJson json = new AltosJson(val);
1282                                                         put(fieldName, json);
1283                                                 }
1284                                         } catch (IllegalAccessException ie) {
1285                                                 System.out.printf("%s:%s %s\n",
1286                                                                   c.getName(), fieldName, ie.toString());
1287                                         }
1288                                 }
1289                         }
1290                 }
1291         }
1292
1293         /* Array constructors, one for each primitive type, String and Object */
1294         public AltosJson(boolean[] bools) {
1295                 assert_array(true);
1296                 for(int i = 0; i < bools.length; i++)
1297                         put(i, new AltosJson(bools[i]));
1298         }
1299
1300         public AltosJson(byte[] numbers) {
1301                 assert_array(true);
1302                 for(int i = 0; i < numbers.length; i++)
1303                         put(i, new AltosJson(numbers[i]));
1304         }
1305
1306         public AltosJson(char[] numbers) {
1307                 assert_array(true);
1308                 for(int i = 0; i < numbers.length; i++)
1309                         put(i, new AltosJson(numbers[i]));
1310         }
1311
1312         public AltosJson(int[] numbers) {
1313                 assert_array(true);
1314                 for(int i = 0; i < numbers.length; i++)
1315                         put(i, new AltosJson(numbers[i]));
1316         }
1317
1318         public AltosJson(long[] numbers) {
1319                 assert_array(true);
1320                 for(int i = 0; i < numbers.length; i++)
1321                         put(i, new AltosJson(numbers[i]));
1322         }
1323
1324         public AltosJson(double[] numbers) {
1325                 assert_array(true);
1326                 for(int i = 0; i < numbers.length; i++)
1327                         put(i, new AltosJson(numbers[i]));
1328         }
1329
1330         public AltosJson(String[] strings) {
1331                 assert_array(true);
1332                 for(int i = 0; i < strings.length; i++)
1333                         put(i, new AltosJson(strings[i]));
1334         }
1335
1336         public AltosJson(AltosJson[] jsons) {
1337                 assert_array(true);
1338                 for (int i = 0; i < jsons.length; i++)
1339                         put(i, jsons[i]);
1340         }
1341
1342         public AltosJson(Object[] array) {
1343                 assert_array(true);
1344                 for (int i = 0; i < array.length; i++)
1345                         put(i, new AltosJson(array[i]));
1346         }
1347
1348         /* Empty constructor
1349          */
1350         public AltosJson() {
1351                 type = type_none;
1352         }
1353
1354         public AltosJson(JsonHash hash) {
1355                 type = type_hash;
1356                 this.hash = hash;
1357         }
1358
1359         public AltosJson(JsonArray array) {
1360                 type = type_array;
1361                 this.array = array;
1362         }
1363 }