xref: /third_party/protobuf/php/src/Google/Protobuf/Internal/GPBJsonWire.php

<?php

// Protocol Buffers - Google's data interchange format
// Copyright 2008 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.

namespace Google\Protobuf\Internal;

class GPBJsonWire
{

    public static function serializeFieldToStream(
        $value,
        $field,
        &$output, $has_field_name = true)
    {
        if ($has_field_name) {
            $output->writeRaw("\"", 1);
            $field_name = GPBJsonWire::formatFieldName($field);
            $output->writeRaw($field_name, strlen($field_name));
            $output->writeRaw("\":", 2);
        }
        return static::serializeFieldValueToStream(
            $value,
            $field,
            $output,
            !$has_field_name);
    }

    public static function serializeFieldValueToStream(
        $values,
        $field,
        &$output,
        $is_well_known = false)
    {
        if ($field->isMap()) {
            $output->writeRaw("{", 1);
            $first = true;
            $map_entry = $field->getMessageType();
            $key_field = $map_entry->getFieldByNumber(1);
            $value_field = $map_entry->getFieldByNumber(2);

            switch ($key_field->getType()) {
            case GPBType::STRING:
            case GPBType::SFIXED64:
            case GPBType::INT64:
            case GPBType::SINT64:
            case GPBType::FIXED64:
            case GPBType::UINT64:
                $additional_quote = false;
                break;
            default:
                $additional_quote = true;
            }

            foreach ($values as $key => $value) {
                if ($first) {
                    $first = false;
                } else {
                    $output->writeRaw(",", 1);
                }
                if ($additional_quote) {
                    $output->writeRaw("\"", 1);
                }
                if (!static::serializeSingularFieldValueToStream(
                    $key,
                    $key_field,
                    $output,
                    $is_well_known)) {
                    return false;
                }
                if ($additional_quote) {
                    $output->writeRaw("\"", 1);
                }
                $output->writeRaw(":", 1);
                if (!static::serializeSingularFieldValueToStream(
                    $value,
                    $value_field,
                    $output,
                    $is_well_known)) {
                    return false;
                }
            }
            $output->writeRaw("}", 1);
            return true;
        } elseif ($field->isRepeated()) {
            $output->writeRaw("[", 1);
            $first = true;
            foreach ($values as $value) {
                if ($first) {
                    $first = false;
                } else {
                    $output->writeRaw(",", 1);
                }
                if (!static::serializeSingularFieldValueToStream(
                    $value,
                    $field,
                    $output,
                    $is_well_known)) {
                    return false;
                }
            }
            $output->writeRaw("]", 1);
            return true;
        } else {
            return static::serializeSingularFieldValueToStream(
                $values,
                $field,
                $output,
                $is_well_known);
        }
    }

    private static function serializeSingularFieldValueToStream(
        $value,
        $field,
        &$output, $is_well_known = false)
    {
        switch ($field->getType()) {
            case GPBType::SFIXED32:
            case GPBType::SINT32:
            case GPBType::INT32:
                $str_value = strval($value);
                $output->writeRaw($str_value, strlen($str_value));
                break;
            case GPBType::FIXED32:
            case GPBType::UINT32:
                if ($value < 0) {
                    $value = bcadd($value, "4294967296");
                }
                $str_value = strval($value);
                $output->writeRaw($str_value, strlen($str_value));
                break;
            case GPBType::FIXED64:
            case GPBType::UINT64:
                if ($value < 0) {
                    $value = bcadd($value, "18446744073709551616");
                }
                // Intentional fall through.
            case GPBType::SFIXED64:
            case GPBType::INT64:
            case GPBType::SINT64:
                $output->writeRaw("\"", 1);
                $str_value = strval($value);
                $output->writeRaw($str_value, strlen($str_value));
                $output->writeRaw("\"", 1);
                break;
            case GPBType::FLOAT:
                if (is_nan($value)) {
                    $str_value = "\"NaN\"";
                } elseif ($value === INF) {
                    $str_value = "\"Infinity\"";
                } elseif ($value === -INF) {
                    $str_value = "\"-Infinity\"";
                } else {
                    $str_value = sprintf("%.8g", $value);
                }
                $output->writeRaw($str_value, strlen($str_value));
                break;
            case GPBType::DOUBLE:
                if (is_nan($value)) {
                    $str_value = "\"NaN\"";
                } elseif ($value === INF) {
                    $str_value = "\"Infinity\"";
                } elseif ($value === -INF) {
                    $str_value = "\"-Infinity\"";
                } else {
                    $str_value = sprintf("%.17g", $value);
                }
                $output->writeRaw($str_value, strlen($str_value));
                break;
            case GPBType::ENUM:
                $enum_desc = $field->getEnumType();
                if ($enum_desc->getClass() === "Google\Protobuf\NullValue") {
                    $output->writeRaw("null", 4);
                    break;
                }
                $enum_value_desc = $enum_desc->getValueByNumber($value);
                if (!is_null($enum_value_desc)) {
                    $str_value = $enum_value_desc->getName();
                    $output->writeRaw("\"", 1);
                    $output->writeRaw($str_value, strlen($str_value));
                    $output->writeRaw("\"", 1);
                } else {
                    $str_value = strval($value);
                    $output->writeRaw($str_value, strlen($str_value));
                }
                break;
            case GPBType::BOOL:
                if ($value) {
                    $output->writeRaw("true", 4);
                } else {
                    $output->writeRaw("false", 5);
                }
                break;
            case GPBType::BYTES:
                $bytes_value = base64_encode($value);
                $output->writeRaw("\"", 1);
                $output->writeRaw($bytes_value, strlen($bytes_value));
                $output->writeRaw("\"", 1);
                break;
            case GPBType::STRING:
                $value = json_encode($value, JSON_UNESCAPED_UNICODE);
                $output->writeRaw($value, strlen($value));
                break;
            //    case GPBType::GROUP:
            //      echo "GROUP\xA";
            //      trigger_error("Not implemented.", E_ERROR);
            //      break;
            case GPBType::MESSAGE:
                $value->serializeToJsonStream($output);
                break;
            default:
                user_error("Unsupported type.");
                return false;
        }
        return true;
    }

    private static function formatFieldName($field)
    {
        return $field->getJsonName();
    }

    // Used for escaping control chars in strings.
    private static $k_control_char_limit = 0x20;

    private static function jsonNiceEscape($c)
    {
      switch ($c) {
          case '"':  return "\\\"";
          case '\\': return "\\\\";
          case '/': return "\\/";
          case '\b': return "\\b";
          case '\f': return "\\f";
          case '\n': return "\\n";
          case '\r': return "\\r";
          case '\t': return "\\t";
          default:   return NULL;
      }
    }

    private static function isJsonEscaped($c)
    {
        // See RFC 4627.
        return $c < chr($k_control_char_limit) || $c === "\"" || $c === "\\";
    }

    public static function escapedJson($value)
    {
        $escaped_value = "";
        $unescaped_run = "";
        for ($i = 0; $i < strlen($value); $i++) {
            $c = $value[$i];
            // Handle escaping.
            if (static::isJsonEscaped($c)) {
                // Use a "nice" escape, like \n, if one exists for this
                // character.
                $escape = static::jsonNiceEscape($c);
                if (is_null($escape)) {
                    $escape = "\\u00" . bin2hex($c);
                }
                if ($unescaped_run !== "") {
                    $escaped_value .= $unescaped_run;
                    $unescaped_run = "";
                }
                $escaped_value .= $escape;
            } else {
              if ($unescaped_run === "") {
                $unescaped_run .= $c;
              }
            }
        }
        $escaped_value .= $unescaped_run;
        return $escaped_value;
    }

}