content: /* Copyright (C) 2016-2018 Alibaba Group Holding Limited
  
  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at
  
      http://www.apache.org/licenses/LICENSE-2.0
  
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
  ==============================================================================*/
  
  // 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 doesn'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('"');
      }
  }
  