C# biz.ritter.javapi.println方法代码示例

        /**
            * Writes a printable representation of this {@code Throwable}'s stack trace
            * to the specified print writer. If the {@code Throwable} contains a
            * {@link #getCause() cause}, the method will be invoked recursively for the
            * nested {@code Throwable}.
            *
            * @param err
            *            the writer to write the stack trace on.
            */
        public virtual void printStackTrace(java.io.PrintWriter err)
        {
            err.println(this.ToString());
            // Don't use getStackTrace() as it calls clone()
            // Get stackTrace, in case stackTrace is reassigned
            StackTraceElement[] stack = getInternalStackTrace();
            foreach (StackTraceElement element in stack) {
                err.println("\tat " + element);
            }

            StackTraceElement[] parentStack = stack;
            Throwable throwable = getCause();
            while (throwable != null) {
                err.print("Caused by: ");
                err.println(throwable);
                StackTraceElement[] currentStack = throwable.getInternalStackTrace();
                int duplicates = countDuplicates(currentStack, parentStack);
                for (int i = 0; i < currentStack.Length - duplicates; i++) {
                    err.println("\tat " + currentStack[i]);
                }
                if (duplicates > 0) {
                    err.println("\t... " + duplicates + " more");
                }
                parentStack = currentStack;
                throwable = throwable.getCause();
            }
        }

        /**
         * Implementation providing functionality for {@link #debugPrint} and for
         * {@link #verbosePrint}.  This prints the given map with nice line breaks.
         * If the debug flag is true, it additionally prints the type of the object
         * value.  If the contents of a map include the map itself, then the text
         * <em>(this Map)</em> is printed out.  If the contents include a
         * parent container of the map, the the text <em>(ancestor[i] Map)</em> is
         * printed, where i actually indicates the number of levels which must be
         * traversed in the sequential list of ancestors (e.g. father, grandfather,
         * great-grandfather, etc).
         *
         * @param out  the stream to print to
         * @param label  the label to be used, may be <code>null</code>.
         *  If <code>null</code>, the label is not output.
         *  It typically represents the name of the property in a bean or similar.
         * @param map  the map to print, may be <code>null</code>.
         *  If <code>null</code>, the text 'null' is output
         * @param lineage  a stack consisting of any maps in which the previous
         *  argument is contained. This is checked to avoid infinite recursion when
         *  printing the output
         * @param debug  flag indicating whether type names should be output.
         * @throws NullPointerException if the stream is <code>null</code>
         */
        private static void verbosePrintInternal(
            java.lang.PrintStream outJ,
            Object label,
            java.util.Map<Object, Object> map,
            ArrayStack lineage,
            bool debug)
        {
            printIndent(outJ, lineage.size());

            if (map == null)
            {
                if (label != null)
                {
                    outJ.print(label);
                    outJ.print(" = ");
                }
                outJ.println("null");
                return;
            }
            if (label != null)
            {
                outJ.print(label);
                outJ.println(" = ");
            }

            printIndent(outJ, lineage.size());
            outJ.println("{");

            lineage.push(map);

            for (java.util.Iterator<java.util.MapNS.Entry<Object, Object>> it = map.entrySet().iterator(); it.hasNext(); )
            {
                java.util.MapNS.Entry<Object, Object> entry = it.next();
                Object childKey = entry.getKey();
                Object childValue = entry.getValue();
                if (childValue is java.util.Map<Object, Object> && !lineage.contains(childValue))
                {
                    verbosePrintInternal(
                        outJ,
                        (childKey == null ? "null" : childKey),
                        (java.util.Map<Object, Object>)childValue,
                        lineage,
                        debug);
                }
                else
                {
                    printIndent(outJ, lineage.size());
                    outJ.print(childKey);
                    outJ.print(" = ");

                    int lineageIndex = lineage.indexOf(childValue);
                    if (lineageIndex == -1)
                    {
                        outJ.print(childValue);
                    }
                    else if (lineage.size() - 1 == lineageIndex)
                    {
                        outJ.print("(this Map)");
                    }
                    else
                    {
                        outJ.print(
                            "(ancestor["
                                + (lineage.size() - 1 - lineageIndex - 1)
                                + "] Map)");
                    }

                    if (debug && childValue != null)
                    {
                        outJ.print(' ');
                        outJ.println(childValue.getClass().getName());
                    }
                    else
                    {
                        outJ.println();
                    }
                }
//.........这里部分代码省略.........