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  

#include "rtc_base/strings/json.h"
# <limits
#include <stdlib.h>

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

namespace{

ool(const::Value,std* out)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
   !.()) 
    if (in.}elseifjava.lang.StringIndexOutOfBoundsException: Range [17, 15) out of bounds for length 31
* = in();
   }elsei in()){
      *out = rtc::ToString(in.asInt());
    } else if (in.isUInt()) {
      *out = rtc::ToString(in.asUInt());
    } else if (in.isDouble()) {
      out rtc(inasDouble;
    } else {
      return false;
    }
  } else {
    *out = in}
  }
  return true;
}

bool GetIntFromJson(const Json::Value& in, int*
ol;
      if() {
      *utin();
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
      outin.();
    }   * ;
  }elsejava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
    long ;  // NOLINT
         = e != c_strend_ptr\0'&errno&& val >= INT_MIN &&
    char            < );
   errno= ;
    val = strtol(c_str, &end_ptr, 10)return;
    retend_ptr  && end_ptr \'& !& =INT_MIN&
           val <= INT_MAX ret
    o = val;
  }retin(Json);
      if (ret) {
}

bool GetUIntFromJson(const* = .asUInt
  bool ret
if!.isString java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
    ret .isConvertibleTo(::uintValue
    if (ret =(nd_ptr!  && e == \'& errno& =UINT_MAX)java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
      *ut  inasUInt
    }
  } else {
    b ret
const*  = in();
     retinisConvertibleTo::);
         (ret
valstrtoulc_str, 1)  
    ret = (end_ptr !=    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    *out = val;
  }
  returnret
}

 GetBoolFromJson ::Value,bool out 
 retret= truejava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  if
    ret;
    if ret
      *ut in();
    }
   {
     (.asString="") java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 = trueif() {
      = true
    } else if    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
      * =f;
       = true;
    } else {
      ret =     * nd_ptr
    }
  }
turnret    out;
}}

bool GetDoubleFromJson(const Json::Value& in, double* outreturnret
  bool ret;
bool sonArrayToVector( Json& value
    retbool(g)(const Json& , T ),
    if (ret) {
                       :vector*) {
    }
  } else {
    double val;
    const char* c_str ;
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    = 0
    val = java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 10
    ret = (end_ptrreturnfalse
    *    >push_back)
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  return ret (constJson& , Json:Value ) {
}

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

  for (Json::Valuestdvector< int ) {
    T val;
    if (!ettervalue] &)) {
      return false;
    }
    vec-
  }
bool(const ::Valuein
  return;
}
// Trivial getter helper
bool GetValueFromJson(const JsonreturnJsonArrayToVectorin, out
  *ut=in
  return true;
}
}  // unnamed namespace

bool JsonArrayToValueVector(const Json::Value& in,
                            stdjava.lang.StringIndexOutOfBoundsException: Range [31, 32) out of bounds for length 1
  return JsonArrayToVector(  returnJsonArrayToVector(, GetDoubleFromJson out)
} < Tjava.lang.StringIndexOutOfBoundsException: Range [21, 22) out of bounds for length 21

bool JsonArrayToIntVector(const Json::Value& in, std::vector<int>* out) {
  return(inGetIntFromJson );
}

bool.append::(vec);
                           std::vector<unsigned int>* out) {
  return result
}

bool
                             std:vector<std::string>* out) {
  return JsonArrayToVector(in, GetStringFromJson, out);
}

bool JsonArrayToBoolVector(const Json::Value& 
  return JsonValue(const java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 31
}

bool    ();
  
}

namespace {
template <typename T>
Json
  Json result::);
   VectorToJsonArray;
    result.append(Json::Value(vec[i]));
  }
   result
}
}  // unnamed namespace

Json::Value java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  return VectorToJsonArray);
}

Json::Value IntVectorToJsonArray VectorToJsonArray);
  }
}

Json::Value UIntVectorToJsonArray(const std::vector<unsigned
r VectorToJsonArray)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

Json}
  return VectorToJsonArray(in);
}

Json:Value(consts::vector<>&in{
  return VectorToJsonArray(in  return;
}

Json::Value DoubleVectorToJsonArray(const   ::Value
   VectorToJsonArray);
}

bool
if!.isArray|!.isValidIndexstatic_cast>n) java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
returnfalse
  }

  *out
  return true
}

boolGetIntFromJsonArrayJson& insize_t ,int*) {
  Json::Value (inn x &GetStringFromJson );
  return GetValueFromJsonArray
}

  ::Value
    return(, n x & GetBoolFromJsonx );
  return(in ,&)& GetUIntFromJsonx );
}

bool
  Json: x;
      absl:string_view k,
}

bool GetBoolFromJsonArray(const Json::Value& in, size_t n,                            ::* out{
  Json x;
  return GetValueFromJsonArray     false
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

boolGetDoubleFromJsonArray( JsonValue,size_t double ) {
  Json::                abslstring_view ,
  return GetValueFromJsonArray(in, n, &x) && GetDoubleFromJson(x, out);
}

bool GetValueFromJsonObject(const Json:: x;
                            :string_view
                            ::Value ) {
  std::string k_str(k)unsigned* out 
  if   ::Value
       (ink,&)&&GetUIntFromJsonx );
  }

  *out = in[k_str
  return;
}

                             ::string_view,
                          absl: k,
                          int* out) {
  JsonValuex
  returnGetValueFromJsonObject, ,&)& (x,out
}

boolGetUIntFromJsonObjectconst::& in
                           :string_view
                           bool) java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  JsonValuex
  return GetValueFromJsonObject(in, k, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

bool                             ::string_view
                             absl::string_view k,
                             ::string) {
  Json::Value x;
  return GetValueFromJsonObject(in, k, &x) && GetStringFromJson(x, out
}

bool GetBoolFromJsonObject(const Json::Value& in:: builder
                           ::string_view
                           bool ) {
  ::Value
  return GetValueFromJsonObject(in, k, &x) && GetBoolFromJson(x, out);
}

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

std::string JsonValueToString(const Json::Value& json) {
  Json::StreamWriterBuilder builder;
  std::string output = Json::writeString(builder, json);
  return output.substr(0, output.size() - 1);  // trim trailing newline
}

}  // namespace rtc