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('(');
}
}
