structure function (v18a, with serializers cache per class, dev.) [1030383]

scope structure.

static bool structure_showTiming, structure_checkTokenCount;

static S structure(O o) {
  ret structure(o, new structure_Data);
}

static S structure(O o, structure_Data d) {
  new StringWriter sw;
  d.out = new PrintWriter(sw);
  structure_go(o, d);
  S s = str(sw);
  if (structure_checkTokenCount) {
    print("token count=" + d.n);
    assertEquals("token count", l(javaTokC(s)), d.n);
  }
  ret s;
}

static void structure_go(O o, structure_Data d) {
  structure_1(o, d);
  while (nempty(d.stack))
    popLast(d.stack).run();
}

static void structureToPrintWriter(O o, PrintWriter out) {
  new structure_Data d;
  d.out = out;
  structure_go(o, d);
}

// leave to false, unless unstructure() breaks
static boolean structure_allowShortening = false;

sinterface #Serializer {
  void serialize(O o);
}

// info on how to serialize objects of a certain class
sclass structure_ClassInfo {
  Serializer serializer;
  L<Field> fields;
  Method customSerializer;
  bool special, nullInstances;
}

sclass #Data {
  PrintWriter out;
  int stringSizeLimit;
  int shareStringsLongerThan = 20;
  bool noStringSharing;

  new IdentityHashMap<O, Integer> seen;
  //new BitSet refd;
  new HashMap<S, Int> strings;
  new HashSet<S> concepts;
  HashMap<Class, structure_ClassInfo> infoByClass = new HashMap;
  new HashMap<Class, Field> persistenceInfo;
  int n; // token count
  new L<Runnable> stack;
  bool unrestructurable; // true if we serialized raw Java objects
  
  // append single token
  structure_Data append(S token) { out.print(token); ++n; ret this; }
  structure_Data append(int i) { out.print(i); ++n; ret this; }
  
  // append multiple tokens
  structure_Data append(S token, int tokCount) { out.print(token); n += tokCount; ret this; }
  
  // extend last token
  structure_Data app(S token) { out.print(token); ret this; }
  structure_Data app(int i) { out.print(i); ret this; }
}

static void structure_1(final Object o, final structure_Data d) ctex {
  if (o == null) { d.append("null"); ret; }
  
  Class c = o.getClass();
  bool concept = false;
  ifclass Concept
    concept = o instanceof Concept;
  endif
  structure_ClassInfo info = d.infoByClass.get(c);
  if (info == null) {
    d.infoByClass.put(c, info = new structure_ClassInfo);
    if ((info.customSerializer = findMethodNamed(c, '_serialize))
      != null) info.special = true;
    info.serializer = makeSerializer(c, info, d);
  }

  info.serializer.serialize(o);

  Field persistenceInfoField = cast d.persistenceInfo.get(c);
  Map<S, O> persistenceInfo = persistenceInfoField == null ? null : (Map) persistenceInfoField.get(o);
  ifdef structure_debug
    print("persistenceInfo for " + c + ": " + persistenceInfo);
  endifdef
  new LinkedHashMap<S, O> fv;
  for (Field f : lFields) {
    Object value;
    try {
      value = f.get(o);
    } catch (Exception e) {
      value = "?";
    }
      
    if (value != null && (persistenceInfo == null
      || !Boolean.FALSE.equals(persistenceInfo.get(f.getName()))))
      fv.put(f.getName(), value);
    ifdef structure_debug
      else print("Skipping null field " + f.getName() + " for " + identityHashCode(o));
    endifdef
  }
  
  S name = c.getName();
  String shortName = dropPrefix("main$", name); // TODO: drop loadableUtils also
  if (startsWithDigit(shortName)) shortName = name; // for anonymous classes
    
  // Now we have fields & values. Process fieldValues if it's a DynamicObject.
  
  // omit field "className" if equal to class's name
  if (concept && eq(fv.get("className"), shortName))
    fv.remove("className");
          
  if (o instanceof DynamicObject) {
    putAll(fv, (Map) fv.get("fieldValues"));
    fv.remove("fieldValues");
    shortName = shortDynamicClassName(o);
    fv.remove("className");
  }
  
  S singleField = fv.size() == 1 ? first(fv.keySet()) : null;
  
  if (concept && !d.concepts.contains(shortName)) {
    d.concepts.add(shortName);
    d.append("c ");
  }
    
  d.append(shortName);
  d.n += countDots(shortName)*2; // correct token count
  ifdef structure_debug
    print("Fields for " + shortName + ": " + fv.keySet());
  endifdef
  
  final int l = d.n;
  final Iterator it = fv.entrySet().iterator();
  
  d.stack.add(r {
    if (!it.hasNext()) {
      if (d.n != l)
        d.append(")");
    } else {
      Map.Entry e = (Map.Entry) it.next();
      d.append(d.n == l ? "(" : ", ");
      d.append((S) e.getKey()).append("=");
      d.stack.add(this);
      structure_1(e.getValue(), d);
    }
  });
}

Serializer #makeSerializer(Class c, ClassInfo info, Data d) {
  // these are never back-referenced (for readability)
  
  if (isSubclassOf(c, Number.class)) {
    PrintWriter out = d.out;
    if (c == Integer) ret o -> { int i = ((Int) o).intValue(); out.print(i); d.n += i < 0 ? 2 : 1; ret; }
    if (c == Long) ret o -> { long l = ((Long) o).longValue(); out.print(l); out.print("L"); d.n += l < 0 ? 2 : 1; ret; }
    if (c == Short) ret o -> { short s = o.shortValue(); d.append("sh "); out.print(s); d.n += s < 0 ? 2 : 1; ret; }
    if (c == Float) ret o -> { d.append("fl ", 2); quoteToPrintWriter(str(o), out); ret; }
    if (c == Double) ret o -> { d.append("d(", 3); quoteToPrintWriter(str(o), out); d.append(")"); ret; }
    if (c == BigInteger) ret o -> { out.print("bigint("); out.print(o); out.print(")"); d.n += ((BigInteger) o).signum() < 0 ? 5 : 4; ret; }
  }

  if (c == Boolean.class) ret o -> {
    d.append(((Boolean) o).booleanValue() ? "t" : "f"); ret;
  };
    
  if (c == Character.class) ret o -> {
    d.append(quoteCharacter((Character) o)); ret;
  };
    
  if (c == File.class) ret o -> {
    d.append("File ").append(quote(((File) o).getPath())); ret;
  };
    
  // referencable objects follow

  Serializer serializer2 = makeSerializer2(c, info, d);
  
  ret o -> {
    Int ref = d.seen.get(o);
    if (o instanceof S && ref == null) ref = d.strings.get((S) o);
    if (ref != null) { /*d.refd.set(ref);*/ d.append("t").app(ref); ret; }
    
    if (!o instanceof S)
      d.seen.put(o, d.n); // record token number
    else {
      S s = d.stringSizeLimit != 0 ? shorten((S) o, d.stringSizeLimit) : (S) o;
      if (!d.noStringSharing) {
        if (d.shareStringsLongerThan == Int.MAX_VALUE)
          d.seen.put(o, d.n);
        if (l(s) >= d.shareStringsLongerThan)
          d.strings.put(s, d.n);
      }
      quoteToPrintWriter(s, d.out); d.n++; ret;
    }

    serializer2.serialize(o);
  };
}

// make serializer for back-referenceable objects
Serializer #makeSerializer2(Class c, ClassInfo info, Data d) {    
  if (isSubclassOf(c, Set.class)) {
    /*O set2 = unwrapSynchronizedSet(o);
    if (set2 != o) {
      d.append("sync");
      o = set2;
    } TODO */
    
    if (isSubclassOf(c, TreeSet.class)) ret o -> {
      d.append(isCISet_gen(o) ? "ciset" : "treeset");
      structure_1(new ArrayList(o), d);
      ret;
    };

    ret o -> {
      // assume it's a HashSet or LinkedHashSet
      d.append(o instanceof LinkedHashSet ? "lhs" : "hashset");
      structure_1(new ArrayList(o), d);
      ret;
    };
  }
  
  S name = c.getName();
  
  if (isSubclassOf(c, Collection.class) && !isJavaXClassName(name)
    /* && neq(name, "main$Concept$RefL") */) {
    
    // it's a list
  
    if (name.equals("java.util.Collections$SynchronizedList")
      || name.equals("java.util.Collections$SynchronizedRandomAccessList")) ret o -> {
      d.append("sync ");
      ret with structure_1(unwrapSynchronizedList(o/List), d);
    };
    bool isLL = name.equals("java.util.LinkedList");
    ret o -> {
      if (isLL) d.append("ll");
      d.append("[");
      final int l = d.n;
      final Iterator it = ((Collection) o).iterator();
      d.stack.add(r {
        if (!it.hasNext())
          d.append("]");
        else {
          d.stack.add(this);
          if (d.n != l) d.append(", ");
          structure_1(it.next(), d);
        }
      });
      ret;
    };
  }
  
  if (isSuperclass Map(c) && !startsWith(name, "main$")) {
    IF0<S> prefix;
    if (isSuperclass LinkedHashMap(c)) prefix = () -> "lhm";
    else if (isSuperclass HashMap(c)) prefix = () -> "hm";
    else if (isSuperclass TreeMap(c))
      prefix = () -> isCIMap_gen(o) ? "cimap" : "tm";
    else if (name.equals("java.util.Collections$SynchronizedMap")
      || name.equals("java.util.Collections$SynchronizedSortedMap")
      || name.equals("java.util.Collections$SynchronizedNavigableMap")) {
      d.append("sync "); 
      ret with structure_1(unwrapSynchronizedMap(o/Map), d);
    } else
      prefix = null;

    ret o -> {
      if (prefix != null) d.append(prefix!);
      d.append("{");
      final int l = d.n;
      final Iterator it = ((Map) o).entrySet().iterator();
      
      d.stack.add(new Runnable {
        bool v;
        Map.Entry e;
        
        run {
          if (v) {
            d.append("=");
            v = false;
            d.stack.add(this);
            structure_1(e.getValue(), d);
          } else {
            if (!it.hasNext())
              d.append("}");
            else {
              e = (Map.Entry) it.next();
              v = true;
              d.stack.add(this);
              if (d.n != l) d.append(", ");
              structure_1(e.getKey(), d);
            }
          }
        }
      });
      ret;
    };
  }
  
  if (c.isArray()) {
    if (o instanceof byte[]) ret o -> {
      d.append("ba ").append(quote(bytesToHex((byte[]) o))); ret;
    };

    if (o instanceof bool[]) ret o -> {
      int n = Array.getLength(o);
      S hex = boolArrayToHex((bool[]) o);
      int i = l(hex);
      while (i > 0 && hex.charAt(i-1) == '0' && hex.charAt(i-2) == '0') i -= 2;
      d.append("boolarray ").append(n).app(" ").append(quote(substring(hex, 0, i))); ret;
    }
    
    S atype/*, sep = ", "*/; // sep is not used yet

    if (o instanceof int[]) {
      //ret "intarray " + quote(intArrayToHex((int[]) o));
      atype = "intarray";
      //sep = " ";
    } else if (o instanceof double[]) {
      atype = "dblarray";
      //sep = " ";
    } else
      atype = "array";

    ret o -> {
      int n = Array.getLength(o);
      d.append(atype).append("{");
      d.stack.add(new Runnable {
        int i;
        run {
          if (i >= n)
            d.append("}");
          else {
            d.stack.add(this);
            if (i > 0) d.append(", ");
            structure_1(Array.get(o, i++), d);
          }
        }
      });
      ret;
    };
  }
  
  if (c == Class.class) ret o -> {
    d.append("class(", 2).append(quote(((Class) o).getName())).append(")"); ret;
  };
    
  if (isSubclassOf(c, Throwable.class)) ret o -> {
    d.append("exception(", 2).append(quote(((Throwable) o).getMessage())).append(")"); ret;
  };
    
  if (c == BitSet.class) ret o -> {
    BitSet bs = (BitSet) o;
    d.append("bitset{", 2);
    int l = d.n;
    for (int i = bs.nextSetBit(0); i >= 0; i = bs.nextSetBit(i+1)) {
      if (d.n != l) d.append(", ");
      d.append(i);
    }
    d.append("}"); ret;
  }
    
  // Need more cases? This should cover all library classes...
  if (name.startsWith("java.") || name.startsWith("javax.")) ret o -> {
    d.unrestructurable = true; // Note: as not unstructure-able
    d.append("j ").append(quote(str(o))); ret;
  };
  
  ifclass Lisp
    if (isSuperclass Lisp(o)) ret o -> {
      d.append("l(", 2);
      Lisp lisp = cast o;
      structure_1(lisp.head, d);
      Iterator it = lisp.args == null ? emptyIterator() : lisp.args.iterator();
      d.stack.add(r {
        if (!it.hasNext())
          d.append(")");
        else {
          d.stack.add(this);
          d.append(", ");
          structure_1(it.next(), d);
        }
      });
      ret;
    };
  endif
    
  /*if (name.equals("main$Lisp")) {
    fail("lisp not supported right now");
  }*/
  
  if (info.special) {
    if (info.customSerializer != null) ret o -> {
      // custom serialization (_serialize method)
      O o2 = invokeMethod(info.customSerializer, o);
      d.append("cu ");
      S shortName = dropPrefix("main$", name);
      d.append(shortName);
      d.out.append(' ');
      structure_1(o2, d);
      ret;
    }; else if (info.nullInstances) ret o -> { d.append("null"); };
    else fail("unknown special type");
  }
  
  // serialize an object with fields.
  // first, collect all fields and values in fv.
  
  TreeSet<Field> fields = new TreeSet<Field>(new Comparator<Field>() {
    public int compare(Field a, Field b) {
      ret stdcompare(a.getName(), b.getName());
    }
  });
  
    Class cc = c;
    while (cc != Object.class) {
      for (Field field : getDeclaredFields_cached(cc)) {
        S fieldName = field.getName();
        if (fieldName.equals("_persistenceInfo"))
          d.persistenceInfo.put(c, field);
        if ((field.getModifiers() & (java.lang.reflect.Modifier.STATIC | java.lang.reflect.Modifier.TRANSIENT)) != 0)
          continue;

        fields.add(field);
        
        // put special cases here...?
      }
        
      cc = cc.getSuperclass();
    }
    
    // TODO: S fieldOrder = getOpt(c, "_fieldOrder");
    lFields = asList(fields);
    
    // Render this$1 first because unstructure needs it for constructor call.
    
    int n = l(lFields);
    for (int i = 0; i < n; i++) {
      Field f = lFields.get(i);
      if (f.getName().equals("this$1")) {
        lFields.remove(i);
        lFields.add(0, f);
        break;
      }
    }
  
    ifdef structure_debug
      print("Saving fields for " + c + ": " + lFields);
    endifdef
    info.fields = lFields;
  } // << if (lFields == null)
  else { // ref handling for lFields != null
    Int ref = d.seen.get(o);
    if (ref != null) { /*d.refd.set(ref);*/ d.append("t").app(ref); ret; }
    d.seen.put(o, d.n); // record token number
  }
}


end scope

Travelled to 4 computer(s): bhatertpkbcr, mqqgnosmbjvj, pyentgdyhuwx, vouqrxazstgt

Snippet ID:	#1030383
Snippet name:	structure function (v18a, with serializers cache per class, dev.)
Eternal ID of this version:	#1030383/8
Text MD5:	3a4878973516a58c8ad4f7d98710c39b
Author:	stefan
Category:	javax
Type:	JavaX fragment (include)
Public (visible to everyone):	Yes
Archived (hidden from active list):	No
Created/modified:	2021-03-16 15:16:00
Source code size:	14251 bytes / 475 lines
Pitched / IR pitched:	No / No
Views / Downloads:	97 / 147
Version history:	7 change(s)
Referenced in:	[show references]

< > BotCompany Repo | #1030383 // structure function (v18a, with serializers cache per class, dev.)

JavaX fragment (include) [tags: use-pretranspiled]

Author comment

1	scope structure.
2
3	static bool structure_showTiming, structure_checkTokenCount;
4
5	static S structure(O o) {
6	ret structure(o, new structure_Data);
7	}
8
9	static S structure(O o, structure_Data d) {
10	new StringWriter sw;
11	d.out = new PrintWriter(sw);
12	structure_go(o, d);
13	S s = str(sw);
14	if (structure_checkTokenCount) {
15	print("token count=" + d.n);
16	assertEquals("token count", l(javaTokC(s)), d.n);
17	}
18	ret s;
19	}
20
21	static void structure_go(O o, structure_Data d) {
22	structure_1(o, d);
23	while (nempty(d.stack))
24	popLast(d.stack).run();
25	}
26
27	static void structureToPrintWriter(O o, PrintWriter out) {
28	new structure_Data d;
29	d.out = out;
30	structure_go(o, d);
31	}
32
33	// leave to false, unless unstructure() breaks
34	static boolean structure_allowShortening = false;
35
36	sinterface #Serializer {
37	void serialize(O o);
38	}
39
40	// info on how to serialize objects of a certain class
41	sclass structure_ClassInfo {
42	Serializer serializer;
43	L<Field> fields;
44	Method customSerializer;
45	bool special, nullInstances;
46	}
47
48	sclass #Data {
49	PrintWriter out;
50	int stringSizeLimit;
51	int shareStringsLongerThan = 20;
52	bool noStringSharing;
53
54	new IdentityHashMap<O, Integer> seen;
55	//new BitSet refd;
56	new HashMap<S, Int> strings;
57	new HashSet<S> concepts;
58	HashMap<Class, structure_ClassInfo> infoByClass = new HashMap;
59	new HashMap<Class, Field> persistenceInfo;
60	int n; // token count
61	new L<Runnable> stack;
62	bool unrestructurable; // true if we serialized raw Java objects
63
64	// append single token
65	structure_Data append(S token) { out.print(token); ++n; ret this; }
66	structure_Data append(int i) { out.print(i); ++n; ret this; }
67
68	// append multiple tokens
69	structure_Data append(S token, int tokCount) { out.print(token); n += tokCount; ret this; }
70
71	// extend last token
72	structure_Data app(S token) { out.print(token); ret this; }
73	structure_Data app(int i) { out.print(i); ret this; }
74	}
75
76	static void structure_1(final Object o, final structure_Data d) ctex {
77	if (o == null) { d.append("null"); ret; }
78
79	Class c = o.getClass();
80	bool concept = false;
81	ifclass Concept
82	concept = o instanceof Concept;
83	endif
84	structure_ClassInfo info = d.infoByClass.get(c);
85	if (info == null) {
86	d.infoByClass.put(c, info = new structure_ClassInfo);
87	if ((info.customSerializer = findMethodNamed(c, '_serialize))
88	!= null) info.special = true;
89	info.serializer = makeSerializer(c, info, d);
90	}
91
92	info.serializer.serialize(o);
93
94	Field persistenceInfoField = cast d.persistenceInfo.get(c);
95	Map<S, O> persistenceInfo = persistenceInfoField == null ? null : (Map) persistenceInfoField.get(o);
96	ifdef structure_debug
97	print("persistenceInfo for " + c + ": " + persistenceInfo);
98	endifdef
99	new LinkedHashMap<S, O> fv;
100	for (Field f : lFields) {
101	Object value;
102	try {
103	value = f.get(o);
104	} catch (Exception e) {
105	value = "?";
106	}
107
108	if (value != null && (persistenceInfo == null
109	\|\| !Boolean.FALSE.equals(persistenceInfo.get(f.getName()))))
110	fv.put(f.getName(), value);
111	ifdef structure_debug
112	else print("Skipping null field " + f.getName() + " for " + identityHashCode(o));
113	endifdef
114	}
115
116	S name = c.getName();
117	String shortName = dropPrefix("main$", name); // TODO: drop loadableUtils also
118	if (startsWithDigit(shortName)) shortName = name; // for anonymous classes
119
120	// Now we have fields & values. Process fieldValues if it's a DynamicObject.
121
122	// omit field "className" if equal to class's name
123	if (concept && eq(fv.get("className"), shortName))
124	fv.remove("className");
125
126	if (o instanceof DynamicObject) {
127	putAll(fv, (Map) fv.get("fieldValues"));
128	fv.remove("fieldValues");
129	shortName = shortDynamicClassName(o);
130	fv.remove("className");
131	}
132
133	S singleField = fv.size() == 1 ? first(fv.keySet()) : null;
134
135	if (concept && !d.concepts.contains(shortName)) {
136	d.concepts.add(shortName);
137	d.append("c ");
138	}
139
140	d.append(shortName);
141	d.n += countDots(shortName)*2; // correct token count
142	ifdef structure_debug
143	print("Fields for " + shortName + ": " + fv.keySet());
144	endifdef
145
146	final int l = d.n;
147	final Iterator it = fv.entrySet().iterator();
148
149	d.stack.add(r {
150	if (!it.hasNext()) {
151	if (d.n != l)
152	d.append(")");
153	} else {
154	Map.Entry e = (Map.Entry) it.next();
155	d.append(d.n == l ? "(" : ", ");
156	d.append((S) e.getKey()).append("=");
157	d.stack.add(this);
158	structure_1(e.getValue(), d);
159	}
160	});
161	}
162
163	Serializer #makeSerializer(Class c, ClassInfo info, Data d) {
164	// these are never back-referenced (for readability)
165
166	if (isSubclassOf(c, Number.class)) {
167	PrintWriter out = d.out;
168	if (c == Integer) ret o -> { int i = ((Int) o).intValue(); out.print(i); d.n += i < 0 ? 2 : 1; ret; }
169	if (c == Long) ret o -> { long l = ((Long) o).longValue(); out.print(l); out.print("L"); d.n += l < 0 ? 2 : 1; ret; }
170	if (c == Short) ret o -> { short s = o.shortValue(); d.append("sh "); out.print(s); d.n += s < 0 ? 2 : 1; ret; }
171	if (c == Float) ret o -> { d.append("fl ", 2); quoteToPrintWriter(str(o), out); ret; }
172	if (c == Double) ret o -> { d.append("d(", 3); quoteToPrintWriter(str(o), out); d.append(")"); ret; }
173	if (c == BigInteger) ret o -> { out.print("bigint("); out.print(o); out.print(")"); d.n += ((BigInteger) o).signum() < 0 ? 5 : 4; ret; }
174	}
175
176	if (c == Boolean.class) ret o -> {
177	d.append(((Boolean) o).booleanValue() ? "t" : "f"); ret;
178	};
179
180	if (c == Character.class) ret o -> {
181	d.append(quoteCharacter((Character) o)); ret;
182	};
183
184	if (c == File.class) ret o -> {
185	d.append("File ").append(quote(((File) o).getPath())); ret;
186	};
187
188	// referencable objects follow
189
190	Serializer serializer2 = makeSerializer2(c, info, d);
191
192	ret o -> {
193	Int ref = d.seen.get(o);
194	if (o instanceof S && ref == null) ref = d.strings.get((S) o);
195	if (ref != null) { /d.refd.set(ref);/ d.append("t").app(ref); ret; }
196
197	if (!o instanceof S)
198	d.seen.put(o, d.n); // record token number
199	else {
200	S s = d.stringSizeLimit != 0 ? shorten((S) o, d.stringSizeLimit) : (S) o;
201	if (!d.noStringSharing) {
202	if (d.shareStringsLongerThan == Int.MAX_VALUE)
203	d.seen.put(o, d.n);
204	if (l(s) >= d.shareStringsLongerThan)
205	d.strings.put(s, d.n);
206	}
207	quoteToPrintWriter(s, d.out); d.n++; ret;
208	}
209
210	serializer2.serialize(o);
211	};
212	}
213
214	// make serializer for back-referenceable objects
215	Serializer #makeSerializer2(Class c, ClassInfo info, Data d) {
216	if (isSubclassOf(c, Set.class)) {
217	/*O set2 = unwrapSynchronizedSet(o);
218	if (set2 != o) {
219	d.append("sync");
220	o = set2;
221	} TODO */
222
223	if (isSubclassOf(c, TreeSet.class)) ret o -> {
224	d.append(isCISet_gen(o) ? "ciset" : "treeset");
225	structure_1(new ArrayList(o), d);
226	ret;
227	};
228
229	ret o -> {
230	// assume it's a HashSet or LinkedHashSet
231	d.append(o instanceof LinkedHashSet ? "lhs" : "hashset");
232	structure_1(new ArrayList(o), d);
233	ret;
234	};
235	}
236
237	S name = c.getName();
238
239	if (isSubclassOf(c, Collection.class) && !isJavaXClassName(name)
240	/* && neq(name, "main$Concept$RefL") */) {
241
242	// it's a list
243
244	if (name.equals("java.util.Collections$SynchronizedList")
245	\|\| name.equals("java.util.Collections$SynchronizedRandomAccessList")) ret o -> {
246	d.append("sync ");
247	ret with structure_1(unwrapSynchronizedList(o/List), d);
248	};
249	bool isLL = name.equals("java.util.LinkedList");
250	ret o -> {
251	if (isLL) d.append("ll");
252	d.append("[");
253	final int l = d.n;
254	final Iterator it = ((Collection) o).iterator();
255	d.stack.add(r {
256	if (!it.hasNext())
257	d.append("]");
258	else {
259	d.stack.add(this);
260	if (d.n != l) d.append(", ");
261	structure_1(it.next(), d);
262	}
263	});
264	ret;
265	};
266	}
267
268	if (isSuperclass Map(c) && !startsWith(name, "main$")) {
269	IF0<S> prefix;
270	if (isSuperclass LinkedHashMap(c)) prefix = () -> "lhm";
271	else if (isSuperclass HashMap(c)) prefix = () -> "hm";
272	else if (isSuperclass TreeMap(c))
273	prefix = () -> isCIMap_gen(o) ? "cimap" : "tm";
274	else if (name.equals("java.util.Collections$SynchronizedMap")
275	\|\| name.equals("java.util.Collections$SynchronizedSortedMap")
276	\|\| name.equals("java.util.Collections$SynchronizedNavigableMap")) {
277	d.append("sync ");
278	ret with structure_1(unwrapSynchronizedMap(o/Map), d);
279	} else
280	prefix = null;
281
282	ret o -> {
283	if (prefix != null) d.append(prefix!);
284	d.append("{");
285	final int l = d.n;
286	final Iterator it = ((Map) o).entrySet().iterator();
287
288	d.stack.add(new Runnable {
289	bool v;
290	Map.Entry e;
291
292	run {
293	if (v) {
294	d.append("=");
295	v = false;
296	d.stack.add(this);
297	structure_1(e.getValue(), d);
298	} else {
299	if (!it.hasNext())
300	d.append("}");
301	else {
302	e = (Map.Entry) it.next();
303	v = true;
304	d.stack.add(this);
305	if (d.n != l) d.append(", ");
306	structure_1(e.getKey(), d);
307	}
308	}
309	}
310	});
311	ret;
312	};
313	}
314
315	if (c.isArray()) {
316	if (o instanceof byte[]) ret o -> {
317	d.append("ba ").append(quote(bytesToHex((byte[]) o))); ret;
318	};
319
320	if (o instanceof bool[]) ret o -> {
321	int n = Array.getLength(o);
322	S hex = boolArrayToHex((bool[]) o);
323	int i = l(hex);
324	while (i > 0 && hex.charAt(i-1) == '0' && hex.charAt(i-2) == '0') i -= 2;
325	d.append("boolarray ").append(n).app(" ").append(quote(substring(hex, 0, i))); ret;
326	}
327
328	S atype/, sep = ", "/; // sep is not used yet
329
330	if (o instanceof int[]) {
331	//ret "intarray " + quote(intArrayToHex((int[]) o));
332	atype = "intarray";
333	//sep = " ";
334	} else if (o instanceof double[]) {
335	atype = "dblarray";
336	//sep = " ";
337	} else
338	atype = "array";
339
340	ret o -> {
341	int n = Array.getLength(o);
342	d.append(atype).append("{");
343	d.stack.add(new Runnable {
344	int i;
345	run {
346	if (i >= n)
347	d.append("}");
348	else {
349	d.stack.add(this);
350	if (i > 0) d.append(", ");
351	structure_1(Array.get(o, i++), d);
352	}
353	}
354	});
355	ret;
356	};
357	}
358
359	if (c == Class.class) ret o -> {
360	d.append("class(", 2).append(quote(((Class) o).getName())).append(")"); ret;
361	};
362
363	if (isSubclassOf(c, Throwable.class)) ret o -> {
364	d.append("exception(", 2).append(quote(((Throwable) o).getMessage())).append(")"); ret;
365	};
366
367	if (c == BitSet.class) ret o -> {
368	BitSet bs = (BitSet) o;
369	d.append("bitset{", 2);
370	int l = d.n;
371	for (int i = bs.nextSetBit(0); i >= 0; i = bs.nextSetBit(i+1)) {
372	if (d.n != l) d.append(", ");
373	d.append(i);
374	}
375	d.append("}"); ret;
376	}
377
378	// Need more cases? This should cover all library classes...
379	if (name.startsWith("java.") \|\| name.startsWith("javax.")) ret o -> {
380	d.unrestructurable = true; // Note: as not unstructure-able
381	d.append("j ").append(quote(str(o))); ret;
382	};
383
384	ifclass Lisp
385	if (isSuperclass Lisp(o)) ret o -> {
386	d.append("l(", 2);
387	Lisp lisp = cast o;
388	structure_1(lisp.head, d);
389	Iterator it = lisp.args == null ? emptyIterator() : lisp.args.iterator();
390	d.stack.add(r {
391	if (!it.hasNext())
392	d.append(")");
393	else {
394	d.stack.add(this);
395	d.append(", ");
396	structure_1(it.next(), d);
397	}
398	});
399	ret;
400	};
401	endif
402
403	/*if (name.equals("main$Lisp")) {
404	fail("lisp not supported right now");
405	}*/
406
407	if (info.special) {
408	if (info.customSerializer != null) ret o -> {
409	// custom serialization (_serialize method)
410	O o2 = invokeMethod(info.customSerializer, o);
411	d.append("cu ");
412	S shortName = dropPrefix("main$", name);
413	d.append(shortName);
414	d.out.append(' ');
415	structure_1(o2, d);
416	ret;
417	}; else if (info.nullInstances) ret o -> { d.append("null"); };
418	else fail("unknown special type");
419	}
420
421	// serialize an object with fields.
422	// first, collect all fields and values in fv.
423
424	TreeSet<Field> fields = new TreeSet<Field>(new Comparator<Field>() {
425	public int compare(Field a, Field b) {
426	ret stdcompare(a.getName(), b.getName());
427	}
428	});
429
430	Class cc = c;
431	while (cc != Object.class) {
432	for (Field field : getDeclaredFields_cached(cc)) {
433	S fieldName = field.getName();
434	if (fieldName.equals("_persistenceInfo"))
435	d.persistenceInfo.put(c, field);
436	if ((field.getModifiers() & (java.lang.reflect.Modifier.STATIC \| java.lang.reflect.Modifier.TRANSIENT)) != 0)
437	continue;
438
439	fields.add(field);
440
441	// put special cases here...?
442	}
443
444	cc = cc.getSuperclass();
445	}
446
447	// TODO: S fieldOrder = getOpt(c, "_fieldOrder");
448	lFields = asList(fields);
449
450	// Render this$1 first because unstructure needs it for constructor call.
451
452	int n = l(lFields);
453	for (int i = 0; i < n; i++) {
454	Field f = lFields.get(i);
455	if (f.getName().equals("this$1")) {
456	lFields.remove(i);
457	lFields.add(0, f);
458	break;
459	}
460	}
461
462	ifdef structure_debug
463	print("Saving fields for " + c + ": " + lFields);
464	endifdef
465	info.fields = lFields;
466	} // << if (lFields == null)
467	else { // ref handling for lFields != null
468	Int ref = d.seen.get(o);
469	if (ref != null) { /d.refd.set(ref);/ d.append("t").app(ref); ret; }
470	d.seen.put(o, d.n); // record token number
471	}
472	}
473
474
475	end scope