JSONBase64 Class Reference

#include <JSON_Base64.h>

Static Public Member Functions
static json_string	json_encode64 (const unsigned char *binary, size_t bytes) json_nothrow json_cold
static std::string	json_decode64 (const json_string &encoded) json_nothrow json_cold
static json_string	json_encode64 (const unsigned char *binary, size_t bytes) json_nothrow json_cold
static std::string	json_decode64 (const json_string &encoded) json_nothrow json_cold

Member Function Documentation

std::string JSONBase64::json_decode64 ( const json_string &  encoded )

static

References chars64(), HitScopeCoverage, JSON_ASSERT_SAFE, json_char, json_global, json_likely, JSON_TEXT, json_unlikely, and toBinary().

Referenced by JSONNode::as_binary(), and libjson::decode64().

                                                                            {
    const size_t length = encoded.length();
    #if defined JSON_DEBUG || defined JSON_SAFE
      size_t pos = encoded.find_first_not_of(chars64);
      if (json_unlikely(pos != json_string::npos)){
         HitScopeCoverage(json_decode64, pos_not_npos);
        JSON_ASSERT_SAFE(encoded[pos] == JSON_TEXT('='), json_global(ERROR_NOT_BASE64), return json_global(EMPTY_STD_STRING););
        if (pos != length - 1){
           HitScopeCoverage(json_decode64, pos_not_lengthminusone);
          JSON_ASSERT_SAFE(pos == length - 2, json_global(ERROR_NOT_BASE64), return json_global(EMPTY_STD_STRING););
          JSON_ASSERT_SAFE(encoded[pos + 1] == JSON_TEXT('='), json_global(ERROR_NOT_BASE64), return json_global(EMPTY_STD_STRING););
        } else {
          HitScopeCoverage(json_decode64, pos_lengthminusone);
        }
      } else {
         HitScopeCoverage(json_decode64, pos_is_npos);
      }
    #endif
    const json_char * runner = encoded.c_str();
    size_t aligned = length / 4; //don't do the last ones as they might be = padding
    std::string result;
    if (json_likely(aligned != 0)){
      HitScopeCoverage(json_decode64, aligned_not_zero);
      --aligned;
      result.reserve((size_t)((float)length / 1.37) + 1);

      //first do the ones that can not have any padding
      for (unsigned int i = 0; i < aligned; ++i){
         HitScopeCoverage(json_decode64, for_loop);
        const json_char second = toBinary(runner[1]);
        const json_char third = toBinary(runner[2]);
        result += (toBinary(runner[0]) << 2) + ((second & 0x30) >> 4);
        result += ((second & 0xf) << 4) + ((third & 0x3c) >> 2);
        result += ((third & 0x3) << 6) + toBinary(runner[3]);
        runner += 4;
      }

      //now do the ones that might have padding, the first two characters can not be padding, so do them quickly
      const json_char second = toBinary(runner[1]);
      result += (toBinary(runner[0]) << 2) + ((second & 0x30) >> 4);
      if (runner[2] != '='){  //not two = pads
         HitScopeCoverage(json_decode64, not_two_pads);
        const json_char third = toBinary(runner[2]);
        result += ((second & 0xf) << 4) + ((third & 0x3c) >> 2);
        if (runner[3] != '='){  //no padding
           HitScopeCoverage(json_decode64, no_padding);
          result += ((third & 0x3) << 6) + toBinary(runner[3]);
        } else {
         HitScopeCoverage(json_decode64, padding_three);
        }
      } else {
         HitScopeCoverage(json_decode64, padding_two);
      }
    } else {
      HitScopeCoverage(json_decode64, aligned_zero);
   }
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static std::string JSONBase64::json_decode64 ( const json_string &  encoded )

static

static json_string JSONBase64::json_encode64 ( const unsigned char *  binary, size_t  bytes  )

static

json_string JSONBase64::json_encode64 ( const unsigned char *  binary, size_t  bytes  )

static

References chars64(), HitScopeCoverage, JSON_ASSERT, json_likely, and JSON_TEXT.

Referenced by libjson::encode64(), and JSONNode::set_binary().

                                                                                             {
    size_t misaligned = bytes % 3;
    json_string result;
    result.reserve((size_t)(((float)bytes) * 1.37f) + 4);

    //do all of the ones that are 3 byte aligned
    for (size_t i = 0, aligned((bytes - misaligned) / 3); i < aligned; ++i){
      HitScopeCoverage(json_encode64, forloop);
      result += chars64[(binary[0] & 0xFC) >> 2];
      result += chars64[((binary[0] & 0x03) << 4) + ((binary[1] & 0xF0) >> 4)];
      result += chars64[((binary[1] & 0x0F) << 2) + ((binary[2] & 0xC0) >> 6)];
      result += chars64[binary[2] & 0x3F];
      binary += 3;
    }
   
    if (json_likely(misaligned != 0)){
      HitScopeCoverage(json_encode64, misaligned);
      //copy the rest into a temporary buffer
      unsigned char temp[3];
      for (unsigned int i = 0; i < misaligned; ++i){
         HitScopeCoverage(json_encode64, misaligned_loop_1);
        temp[i] = *binary++;
      }
      for (unsigned int i = (unsigned int)misaligned; i < 3; ++i){
         HitScopeCoverage(json_encode64, misaligned_loop_2);
        temp[i] = '\0';
      }

      //now do the final three bytes
      result += chars64[(temp[0] & 0xFC) >> 2];
      result += chars64[((temp[0] & 0x03) << 4) + ((temp[1] & 0xF0) >> 4)];
      if (misaligned == 2){
         HitScopeCoverage(json_encode64, misaligned_equals_two);
        result += chars64[((temp[1] & 0x0F) << 2) + ((temp[2] & 0xC0) >> 6)];
        result += JSON_TEXT('=');
      } else {
         HitScopeCoverage(json_encode64, misaligned_not_two);
        result += JSON_TEXT("==");
      }
    } else {
      HitScopeCoverage(json_encode64, notmisaligned);
   }
    JSON_ASSERT((size_t)(((float)bytes) * 1.37f) + 4 >= result.length(), JSON_TEXT("Didn't reserve enough space for a one-time go"));
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• Documentation/Operator-Console/JSON/JSON_Base64.h
• Documentation/Operator-Console/JSON/JSON_Base64.cpp