public void TestStackOverflow() { StringBuilder builder = new StringBuilder(); Persister persister = new Persister(); builder.append("<delivery>"); bool isNewBenefit = true; for(int i = 0; i < ITERATIONS; i++) { String text = null; if(isNewBenefit) { text = NEW_BENEFIT; } else { text = BENEFIT_MUTATION; } isNewBenefit = !isNewBenefit ; builder.append(text); } builder.append("</delivery>"); Delivery delivery = persister.read(Delivery.class, builder.toString());
public synchronized String toString() { StringBuilder builder = new StringBuilder(); int peers = numBroadcastPeers(); if (peers > 0) { builder.append("Seen by "); builder.append(peers); if (peers > 1) builder.append(" peers. "); else builder.append(" peer. "); } switch (getConfidenceType()) { case UNKNOWN: builder.append("Unknown confidence level."); break; case DEAD: builder.append("Dead: overridden by double spend and will not confirm."); break; case NOT_IN_BEST_CHAIN: builder.append("Seen in side chain but not best chain."); break; case NOT_SEEN_IN_CHAIN: builder.append("Not seen in chain."); break; case BUILDING: builder.append(String.format("Appeared in best chain at height %d, depth %d, work done %s.", getAppearedAtChainHeight(), getDepthInBlocks(), getWorkDone())); break; } return builder.toString(); }
/// <summary> /// This is used to build a string from the annotation. The string /// produces adheres to the typical string representation of a /// normal annotation. This ensures that an exceptions that are /// thrown with a string representation of the annotation are /// identical to those thrown with a normal annotation. /// </summary> /// <param name="builder"> /// this is the builder used to compose the text /// </param> public void Attributes(StringBuilder builder) { Method[] list = type.getDeclaredMethods(); for(int i = 0; i < list.length; i++) { String attribute = list[i].getName(); Object value = Value(list[i]); if(i > 0) { builder.append(','); builder.append(' '); } builder.append(attribute); builder.append('='); builder.append(value); } builder.append(')'); }
/** * Returns a string containing the string representation of all modifiers * present in the specified modifiers. Modifiers appear in the order * specified by the Java Language Specification: * * {@code public private protected abstract static readonly transient volatile native synchronized interface strict} * * @param modifiers * the modifiers to print * @return a printable representation of the modifiers */ public static String toString(int modifiers) { StringBuilder buf = new StringBuilder(); if (isPublic(modifiers)) { buf.append("public "); } if (isProtected(modifiers)) { buf.append("protected "); } if (isPrivate(modifiers)) { buf.append("private "); } if (isAbstract(modifiers)) { buf.append("abstract "); } if (isStatic(modifiers)) { buf.append("static "); } if (isFinal(modifiers)) { buf.append("readonly "); } if (isTransient(modifiers)) { buf.append("transient "); } if (isVolatile(modifiers)) { buf.append("volatile "); } if (isSynchronized(modifiers)) { buf.append("synchronized "); } if (isNative(modifiers)) { buf.append("native "); } if (isStrict(modifiers)) { buf.append("strictfp "); } if (isInterface(modifiers)) { buf.append("interface "); } if (buf.length() == 0) { return ""; } buf.setLength(buf.length() - 1); return buf.toString(); }
/// <summary> /// This is used to build a string from the annotation. The string /// produces adheres to the typical string representation of a /// normal annotation. This ensures that an exceptions that are /// thrown with a string representation of the annotation are /// identical to those thrown with a normal annotation. /// </summary> /// <param name="builder"> /// this is the builder used to compose the text /// </param> public void Name(StringBuilder builder) { String name = type.getName(); if(name != null) { builder.append('@'); builder.append(name); builder.append('('); } }