| // Protocol Buffers - Google's data interchange format |
| // Copyright 2013 Google Inc. All rights reserved. |
| // https://developers.google.com/protocol-buffers/ |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are |
| // met: |
| // |
| // * Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // * Redistributions in binary form must reproduce the above |
| // copyright notice, this list of conditions and the following disclaimer |
| // in the documentation and/or other materials provided with the |
| // distribution. |
| // * Neither the name of Google Inc. nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| package com.google.protobuf.nano; |
| |
| import java.lang.reflect.Array; |
| import java.lang.reflect.Field; |
| import java.lang.reflect.InvocationTargetException; |
| import java.lang.reflect.Method; |
| import java.lang.reflect.Modifier; |
| import java.util.Map; |
| |
| /** |
| * Static helper methods for printing nano protos. |
| * |
| * @author flynn@google.com Andrew Flynn |
| */ |
| public final class MessageNanoPrinter { |
| // Do not allow instantiation |
| private MessageNanoPrinter() {} |
| |
| private static final String INDENT = " "; |
| private static final int MAX_STRING_LEN = 200; |
| |
| /** |
| * Returns an text representation of a MessageNano suitable for debugging. The returned string |
| * is mostly compatible with Protocol Buffer's TextFormat (as provided by non-nano protocol |
| * buffers) -- groups (which are deprecated) are output with an underscore name (e.g. foo_bar |
| * instead of FooBar) and will thus not parse. |
| * |
| * <p>Employs Java reflection on the given object and recursively prints primitive fields, |
| * groups, and messages.</p> |
| */ |
| public static <T extends MessageNano> String print(T message) { |
| if (message == null) { |
| return ""; |
| } |
| |
| StringBuffer buf = new StringBuffer(); |
| try { |
| print(null, message, new StringBuffer(), buf); |
| } catch (IllegalAccessException e) { |
| return "Error printing proto: " + e.getMessage(); |
| } catch (InvocationTargetException e) { |
| return "Error printing proto: " + e.getMessage(); |
| } |
| return buf.toString(); |
| } |
| |
| /** |
| * Function that will print the given message/field into the StringBuffer. |
| * Meant to be called recursively. |
| * |
| * @param identifier the identifier to use, or {@code null} if this is the root message to |
| * print. |
| * @param object the value to print. May in fact be a primitive value or byte array and not a |
| * message. |
| * @param indentBuf the indentation each line should begin with. |
| * @param buf the output buffer. |
| */ |
| private static void print(String identifier, Object object, |
| StringBuffer indentBuf, StringBuffer buf) throws IllegalAccessException, |
| InvocationTargetException { |
| if (object == null) { |
| // This can happen if... |
| // - we're about to print a message, String, or byte[], but it not present; |
| // - we're about to print a primitive, but "reftype" optional style is enabled, and |
| // the field is unset. |
| // In both cases the appropriate behavior is to output nothing. |
| } else if (object instanceof MessageNano) { // Nano proto message |
| int origIndentBufLength = indentBuf.length(); |
| if (identifier != null) { |
| buf.append(indentBuf).append(deCamelCaseify(identifier)).append(" <\n"); |
| indentBuf.append(INDENT); |
| } |
| Class<?> clazz = object.getClass(); |
| |
| // Proto fields follow one of two formats: |
| // |
| // 1) Public, non-static variables that do not begin or end with '_' |
| // Find and print these using declared public fields |
| for (Field field : clazz.getFields()) { |
| int modifiers = field.getModifiers(); |
| String fieldName = field.getName(); |
| if ("cachedSize".equals(fieldName)) { |
| // TODO(bduff): perhaps cachedSize should have a more obscure name. |
| continue; |
| } |
| |
| if ((modifiers & Modifier.PUBLIC) == Modifier.PUBLIC |
| && (modifiers & Modifier.STATIC) != Modifier.STATIC |
| && !fieldName.startsWith("_") |
| && !fieldName.endsWith("_")) { |
| Class<?> fieldType = field.getType(); |
| Object value = field.get(object); |
| |
| if (fieldType.isArray()) { |
| Class<?> arrayType = fieldType.getComponentType(); |
| |
| // bytes is special since it's not repeated, but is represented by an array |
| if (arrayType == byte.class) { |
| print(fieldName, value, indentBuf, buf); |
| } else { |
| int len = value == null ? 0 : Array.getLength(value); |
| for (int i = 0; i < len; i++) { |
| Object elem = Array.get(value, i); |
| print(fieldName, elem, indentBuf, buf); |
| } |
| } |
| } else { |
| print(fieldName, value, indentBuf, buf); |
| } |
| } |
| } |
| |
| // 2) Fields that are accessed via getter methods (when accessors |
| // mode is turned on) |
| // Find and print these using getter methods. |
| for (Method method : clazz.getMethods()) { |
| String name = method.getName(); |
| // Check for the setter accessor method since getters and hazzers both have |
| // non-proto-field name collisions (hashCode() and getSerializedSize()) |
| if (name.startsWith("set")) { |
| String subfieldName = name.substring(3); |
| |
| Method hazzer = null; |
| try { |
| hazzer = clazz.getMethod("has" + subfieldName); |
| } catch (NoSuchMethodException e) { |
| continue; |
| } |
| // If hazzer does't exist or returns false, no need to continue |
| if (!(Boolean) hazzer.invoke(object)) { |
| continue; |
| } |
| |
| Method getter = null; |
| try { |
| getter = clazz.getMethod("get" + subfieldName); |
| } catch (NoSuchMethodException e) { |
| continue; |
| } |
| |
| print(subfieldName, getter.invoke(object), indentBuf, buf); |
| } |
| } |
| if (identifier != null) { |
| indentBuf.setLength(origIndentBufLength); |
| buf.append(indentBuf).append(">\n"); |
| } |
| } else if (object instanceof Map) { |
| Map<?,?> map = (Map<?,?>) object; |
| identifier = deCamelCaseify(identifier); |
| |
| for (Map.Entry<?,?> entry : map.entrySet()) { |
| buf.append(indentBuf).append(identifier).append(" <\n"); |
| int origIndentBufLength = indentBuf.length(); |
| indentBuf.append(INDENT); |
| print("key", entry.getKey(), indentBuf, buf); |
| print("value", entry.getValue(), indentBuf, buf); |
| indentBuf.setLength(origIndentBufLength); |
| buf.append(indentBuf).append(">\n"); |
| } |
| } else { |
| // Non-null primitive value |
| identifier = deCamelCaseify(identifier); |
| buf.append(indentBuf).append(identifier).append(": "); |
| if (object instanceof String) { |
| String stringMessage = sanitizeString((String) object); |
| buf.append("\"").append(stringMessage).append("\""); |
| } else if (object instanceof byte[]) { |
| appendQuotedBytes((byte[]) object, buf); |
| } else { |
| buf.append(object); |
| } |
| buf.append("\n"); |
| } |
| } |
| |
| /** |
| * Converts an identifier of the format "FieldName" into "field_name". |
| */ |
| private static String deCamelCaseify(String identifier) { |
| StringBuffer out = new StringBuffer(); |
| for (int i = 0; i < identifier.length(); i++) { |
| char currentChar = identifier.charAt(i); |
| if (i == 0) { |
| out.append(Character.toLowerCase(currentChar)); |
| } else if (Character.isUpperCase(currentChar)) { |
| out.append('_').append(Character.toLowerCase(currentChar)); |
| } else { |
| out.append(currentChar); |
| } |
| } |
| return out.toString(); |
| } |
| |
| /** |
| * Shortens and escapes the given string. |
| */ |
| private static String sanitizeString(String str) { |
| if (!str.startsWith("http") && str.length() > MAX_STRING_LEN) { |
| // Trim non-URL strings. |
| str = str.substring(0, MAX_STRING_LEN) + "[...]"; |
| } |
| return escapeString(str); |
| } |
| |
| /** |
| * Escape everything except for low ASCII code points. |
| */ |
| private static String escapeString(String str) { |
| int strLen = str.length(); |
| StringBuilder b = new StringBuilder(strLen); |
| for (int i = 0; i < strLen; i++) { |
| char original = str.charAt(i); |
| if (original >= ' ' && original <= '~' && original != '"' && original != '\'') { |
| b.append(original); |
| } else { |
| b.append(String.format("\\u%04x", (int) original)); |
| } |
| } |
| return b.toString(); |
| } |
| |
| /** |
| * Appends a quoted byte array to the provided {@code StringBuffer}. |
| */ |
| private static void appendQuotedBytes(byte[] bytes, StringBuffer builder) { |
| if (bytes == null) { |
| builder.append("\"\""); |
| return; |
| } |
| |
| builder.append('"'); |
| for (int i = 0; i < bytes.length; ++i) { |
| int ch = bytes[i] & 0xff; |
| if (ch == '\\' || ch == '"') { |
| builder.append('\\').append((char) ch); |
| } else if (ch >= 32 && ch < 127) { |
| builder.append((char) ch); |
| } else { |
| builder.append(String.format("\\%03o", ch)); |
| } |
| } |
| builder.append('"'); |
| } |
| } |