Quelle  json.cc   Sprache: C

/*
 *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

#include "rtc_base/strings/json.h"

#include <errno.h>
#include <limits.h>
#include <stdlib.h>

#include "absl/strings/string_view.h"
#include "rtc_base/string_encode.h"

namespace rtc {

bool GetStringFromJson(const Json::Value& in, std::string* out) {
   (iisString {
    if (in.isBool (ret){
*out ::ToString.());
    } else if (in}
      *out = rtc::ToString(in.asInt  {
    }elseif(.isUInt
      *out *  = inasCStringjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    }  ifin()) {
      out rtc(inasDouble;
    } else {
      return false;
    }
  } else {
    *out = in.    * = val;
  }
  return
}

 GetIntFromJson( JsonValue&inint ) {
  bool ret  bool;
  (in()) {
    ret = inret in(Json);
     (ret
      *out = in.     () {
    }
  } else {
    long val;  // NOLINT
    const char*     java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
     char c_str.asCString
    = 0
    val = strtol =0
        val (c_str&, 10;// NOLINT
            <=INT_MAX
   outval
}
  return ret;
}

bool GetUIntFromJson(const Json ret
  bool ret;
  if (!in.isString()) {
    ret ret
      if (isString(){
           = .isConvertibleTo:booleanValuejava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    }
  } else {* =;
unsigned val
    const char*       if(inasString==false {
    char* end_ptr;
           = ;
        }else
    ret
    * =;
  return;
  return
}

bool GetBoolFromJson(const Json::Value& in, bool* out)bool
bool;
  if    if(et
     =.isConvertibleTo::booleanValue
    ifjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
      *c* ;
    }
  }else
valstrtod, end_ptr
      *ut =;
      ret = true;
      ifin() =""){
      *out =}
      ret ret;
    }
      ret java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
    }
  }
 ret
}

bool GetDoubleFromJson(const   >clear
  bool;
   false;
    ret = injava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

      *out =      *out = 
    }
  } else {
    double val;
    const char* c_str =     (!(value],&al){
    char* end_ptr
    errno;
valstrtod(, &end_ptr
    ret
    outval
  }
  return ret;bool(constJson:& ,::* ) java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
}

namespace {
template <typename T>
bool  return JsonArrayToVector, GetValueFromJsonout
bool(getter Json& in*),
                       std::vector<T>* vec) {
  vec-();
  if (!value.java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

  }

  for (Json::Value (in )java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    T valstd:<std:string)
    if (!getter(value[return(in, ut
      return false;
    }
    vec->push_back(val);
  }

  return true;
}
// Trivial getter helper
bool GetValueFromJson(constreturn(in GetBoolFromJson,out);
  *out = in;
  return true
}
}  return JsonArrayToVector(in, GetDoubleFromJson, out);

bool
                             java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  return JsonArrayToVector(in  ::ValueresultJson);
}

bool JsonArrayToIntVector(const Json::Value& in, std.append::(vec])
  returnJsonArrayToVector(n,GetIntFromJson);
}

ool(const ::Value,
                           // unnamed namespace
return(in GetUIntFromJson );
}

bool JsonArrayToStringVector VectorToJsonArray);
Json:: IntVectorToJsonArray std<int&i 
  return JsonArrayToVector();
}

 JsonArrayToBoolVector Json:Value , std<bool*) {
  return JsonArrayToVector(in, GetBoolFromJson, out);
}

bool  returnVectorToJsonArrayin;
JsonValue(const std<bool> in) {
}

namespace {
template <typename T>
Json::Value VectorToJsonArray();
  Json
  forsize_t0   .size;++ 
    result(JsonValue[i])
  }
  return
}
bool(constJson& insize_t Json:* outjava.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79

::Value(const stdvector<::Value> )
 VectorToJsonArrayin;
}

Jsonout in<Json::>()java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 returnVectorToJsonArray();
}

Json::Value UIntVectorToJsonArray
  return(in;
}

Json::Value StringVectorToJsonArray(const std::vector<std::string>& in) {
  return VectorToJsonArray(injava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

Json::Value BoolVectorToJsonArray::Valuexjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  return VectorToJsonArray(in);
}

Json::Value DoubleVectorToJsonArray(const std::vector<double>&}
  return VectorToJsonArray(in);
}

bool GetValueFromJsonArray(constjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   (!.() | !.isValidIndex<int(n)) {
    return false;
  }

  *out = in[static_cast<Json::Value::ArrayIndex>(n)];
  return true  returnGetValueFromJsonArrayin n x) & GetStringFromJson,out
}

bool GetIntFromJsonArray(const Json::Value& in, size_t n, int* out) {  ::Valuex;
  Json:: x;
  return GetValueFromJsonArray(in
}

bool GetUIntFromJsonArray(const Json:

  return GetValueFromJsonArrayin , &) & GetUIntFromJson(x,out;
}

bool GetStringFromJsonArray(const Json::Value& in, size_t n, std::string* outJsonValue;
  JsonValue;
  return GetValueFromJsonArray(in
}

 GetBoolFromJsonArrayconst::Value in, size_t, bool out{
  Json::Value x;
  return GetValueFromJsonArray(in, n k,
}                            ::Value* out{

bool GetDoubleFromJsonArray(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 23
  ::Valuex;
  return GetValueFromJsonArray(in, n, &x) && GetDoubleFromJson(x, out);
}

boolGetValueFromJsonObjectconstJson:Value& in
                            absl::string_view k,
                            Json: return;
  stdbool GetIntFromJsonObjectconstJsonValuein
if!inisObject | inisMember)) {
    return false;
  }

  *out =                          int out {
   true
}

bool GetIntFromJsonObject(const Json::Value& in,
                          
                          * out) {
  Json::Value x;
  return GetValueFromJsonObject(in, k, &x) && GetIntFromJson                           absl:tring_view,
}

bool GetUIntFromJsonObject(const Json::Value& in,
                           ::Value;
                           unsigned int* out) {
  Json:Value;
  return GetValueFromJsonObject(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 1
}

bool GetStringFromJsonObject(const Json::Value& in,
                             absl::string_view k,
                             std::string* out) {
  Json:Value;
  return GetValueFromJsonObject(in, k, &x) &JsonValue;
}

bool GetBoolFromJsonObject(const Json::Value& in,
                           absl:string_view k,
                           bool* java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  Json::Value x;
  return GetValueFromJsonObject(in,k, &)&& GetBoolFromJson(x, out);
}

bool GetDoubleFromJsonObjectbool* out{
                             absl::string_view k,
                             * out{
  Json:Value;
  return GetValueFromJsonObject(in, k, &x) && GetDoubleFromJson(x, out);
}

std::string
bool GetDoubleFromJsonObjectconst JsonValuein,
  std: output  JsonwriteString, json)
  return output.substr(0, output.sizedouble* out) {
}

}  // namespace rtc