/*

 *  Copyright (c) 2014, Facebook, Inc.

 *  All rights reserved.

 *

 *  This source code is licensed under the BSD-style license found in the

 *  LICENSE file in the root directory of this source tree. An additional grant

 *  of patent rights can be found in the PATENTS file in the same directory.

 *

 */

/*

 * This header defines JsonbDocument, JsonbKeyValue, and various value classes

 * which are derived from JsonbValue, and a forward iterator for container

 * values - essentially everything that is related to JSONB binary data

 * structures.

 *

 * Implementation notes:

 *

 * None of the classes in this header file can be instantiated directly (i.e.

 * you cannot create a JsonbKeyValue or JsonbValue object - all constructors

 * are declared non-public). We use the classes as wrappers on the packed JSONB

 * bytes (serialized), and cast the classes (types) to the underlying packed

 * byte array.

 *

 * For the same reason, we cannot define any JSONB value class to be virtual,

 * since we never call constructors, and will not instantiate vtbl and vptrs.

 *

 * Therefore, the classes are defined as packed structures (i.e. no data

 * alignment and padding), and the private member variables of the classes are

 * defined precisely in the same order as the JSONB spec. This ensures we

 * access the packed JSONB bytes correctly.

 *

 * The packed structures are highly optimized for in-place operations with low

 * overhead. The reads (and in-place writes) are performed directly on packed

 * bytes. There is no memory allocation at all at runtime.

 *

 * For updates/writes of values that will expand the original JSONB size, the

 * write will fail, and the caller needs to handle buffer increase.

 *

 * ** Iterator **

 * Both ObjectVal class and ArrayVal class have iterator type that you can use

 * to declare an iterator on a container object to go through the key-value

 * pairs or value list. The iterator has both non-const and const types.

 *

 * Note: iterators are forward direction only.

 *

 * ** Query **

 * Querying into containers is through the member functions find (for key/value

 * pairs) and get (for array elements), and is in streaming style. We don't

 * need to read/scan the whole JSONB packed bytes in order to return results.

 * Once the key/index is found, we will stop search.  You can use text to query

 * both objects and array (for array, text will be converted to integer index),

 * and use index to retrieve from array. Array index is 0-based.

 *

 * ** External dictionary **

 * During query processing, you can also pass a call-back function, so the

 * search will first try to check if the key string exists in the dictionary.

 * If so, search will be based on the id instead of the key string.

 * @author Tian Xia <tianx@fb.com>

 * 

 * this file is copied from 

 * https://github.com/facebook/mysql-5.6/blob/fb-mysql-5.6.35/fbson/FbsonDocument.h

 * and modified by Doris

 */

#ifndef JSONB_JSONBDOCUMENT_H

#define JSONB_JSONBDOCUMENT_H

#include <algorithm>

#include <cctype>

#include <charconv>

#include <limits>

#include <string>

#include <type_traits>

#include "common/compiler_util.h" // IWYU pragma: keep

#include "common/status.h"

// #include "util/string_parser.hpp"

namespace doris {

#if defined(__clang__)

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wzero-length-array"

#endif

#pragma pack(push, 1)

#define JSONB_VER 1

using int128_t = __int128;

// forward declaration

class JsonbValue;

class ObjectVal;

const int MaxNestingLevel = 100;

/*

 * JsonbType defines 10 primitive types and 2 container types, as described

 * below.

 *

 * primitive_value ::=

 *   0x00        //null value (0 byte)

 * | 0x01        //boolean true (0 byte)

 * | 0x02        //boolean false (0 byte)

 * | 0x03 int8   //char/int8 (1 byte)

 * | 0x04 int16  //int16 (2 bytes)

 * | 0x05 int32  //int32 (4 bytes)

 * | 0x06 int64  //int64 (8 bytes)

 * | 0x07 double //floating point (8 bytes)

 * | 0x08 string //variable length string

 * | 0x09 binary //variable length binary

 *

 * container ::=

 *   0x0A int32 key_value_list //object, int32 is the total bytes of the object

 * | 0x0B int32 value_list     //array, int32 is the total bytes of the array

 */

enum class JsonbType : char {

    T_Null = 0x00,

    T_True = 0x01,

    T_False = 0x02,

    T_Int8 = 0x03,

    T_Int16 = 0x04,

    T_Int32 = 0x05,

    T_Int64 = 0x06,

    T_Double = 0x07,

    T_String = 0x08,

    T_Binary = 0x09,

    T_Object = 0x0A,

    T_Array = 0x0B,

    T_Int128 = 0x0C,

    T_Float = 0x0D,

    NUM_TYPES,

};

//for parse json path

constexpr char SCOPE = '$';

constexpr char BEGIN_MEMBER = '.';

constexpr char BEGIN_ARRAY = '[';

constexpr char END_ARRAY = ']';

constexpr char DOUBLE_QUOTE = '"';

constexpr char WILDCARD = '*';

constexpr char MINUS = '-';

constexpr char LAST[] = "last";

constexpr char ESCAPE = '\\';

constexpr unsigned int MEMBER_CODE = 0;

constexpr unsigned int ARRAY_CODE = 1;

/*

 * JsonbDocument is the main object that accesses and queries JSONB packed

 * bytes. NOTE: JsonbDocument only allows object container as the top level

 * JSONB value. However, you can use the static method "createValue" to get any

 * JsonbValue object from the packed bytes.

 *

 * JsonbDocument object also dereferences to an object container value

 * (ObjectVal) once JSONB is loaded.

 *

 * ** Load **

 * JsonbDocument is usable after loading packed bytes (memory location) into

 * the object. We only need the header and first few bytes of the payload after

 * header to verify the JSONB.

 *

 * Note: creating an JsonbDocument (through createDocument) does not allocate

 * any memory. The document object is an efficient wrapper on the packed bytes

 * which is accessed directly.

 *

 * ** Query **

 * Query is through dereferencing into ObjectVal.

 */

class JsonbDocument {

public:

    // create an JsonbDocument object from JSONB packed bytes

    [[nodiscard]] static Status checkAndCreateDocument(const char* pb, size_t size,

                                                       JsonbDocument** doc);

    // create an JsonbValue from JSONB packed bytes

    static JsonbValue* createValue(const char* pb, uint32_t size);

    uint8_t version() const { return header_.ver_; }

    JsonbValue* getValue() { return ((JsonbValue*)payload_); }

    void setValue(const JsonbValue* value);

    unsigned int numPackedBytes() const;

    ObjectVal* operator->() { return ((ObjectVal*)payload_); }

    const ObjectVal* operator->() const { return ((const ObjectVal*)payload_); }

    bool operator==(const JsonbDocument& other) const {

        assert(false);

        return false;

    }

    bool operator!=(const JsonbDocument& other) const {

        assert(false);

        return false;

    }

    bool operator<=(const JsonbDocument& other) const {

        assert(false);

        return false;

    }

    bool operator>=(const JsonbDocument& other) const {

        assert(false);

        return false;

    }

    bool operator<(const JsonbDocument& other) const {

        assert(false);

        return false;

    }

    bool operator>(const JsonbDocument& other) const {

        assert(false);

        return false;

    }

private:

    /*

   * JsonbHeader class defines JSONB header (internal to JsonbDocument).

   *

   * Currently it only contains version information (1-byte). We may expand the

   * header to include checksum of the JSONB binary for more security.

   */

    struct JsonbHeader {

        uint8_t ver_;

    } header_;

    char payload_[0];

};

/// A simple input stream class for the JSON path parser.

class Stream {

public:

    /// Creates an input stream reading from a character string.

    /// @param string  the input string

    /// @param length  the length of the input string

    Stream(const char* string, size_t length) : m_position(string), m_end(string + length) {}

    /// Returns a pointer to the current position in the stream.

    const char* position() const { return m_position; }

    /// Returns a pointer to the position just after the end of the stream.

    const char* end() const { return m_end; }

    /// Returns the number of bytes remaining in the stream.

    size_t remaining() const {

        assert(m_position <= m_end);

        return m_end - m_position;

    }

    /// Tells if the stream has been exhausted.

    bool exhausted() const { return remaining() == 0; }

    /// Reads the next byte from the stream and moves the position forward.

    char read() {

        assert(!exhausted());

        return *m_position++;

    }

    /// Reads the next byte from the stream without moving the position forward.

    char peek() const {

        assert(!exhausted());

        return *m_position;

    }

    /// Moves the position to the next non-whitespace character.

    void skip_whitespace() {

        m_position = std::find_if_not(m_position, m_end, [](char c) { return std::isspace(c); });

    }

    /// Moves the position n bytes forward.

    void skip(size_t n) {

        assert(remaining() >= n);

        m_position += n;

        skip_whitespace();

    }

    void clear_leg_ptr() { leg_ptr = nullptr; }

    void set_leg_ptr(char* ptr) {

        clear_leg_ptr();

        leg_ptr = ptr;

    }

    char* get_leg_ptr() { return leg_ptr; }

    void clear_leg_len() { leg_len = 0; }

    void add_leg_len() { leg_len++; }

    unsigned int get_leg_len() const { return leg_len; }

    void remove_escapes() {

        int new_len = 0;

        for (int i = 0; i < leg_len; i++) {

  Branch (299:25): [True: 0, False: 0]

            if (leg_ptr[i] != '\\') {

  Branch (300:17): [True: 0, False: 0]

                leg_ptr[new_len++] = leg_ptr[i];

            }

        }

        leg_ptr[new_len] = '\0';

        leg_len = new_len;

    }

    void set_has_escapes(bool has) { has_escapes = has; }

    bool get_has_escapes() const { return has_escapes; }

private:

    /// The current position in the stream.

    const char* m_position = nullptr;

    /// The end of the stream.

    const char* const m_end;

    ///path leg ptr

    char* leg_ptr = nullptr;

    ///path leg len

    unsigned int leg_len;

    ///Whether to contain escape characters

    bool has_escapes = false;

};

struct leg_info {

    ///path leg ptr

    char* leg_ptr = nullptr;

    ///path leg len

    unsigned int leg_len;

    ///array_index

    int array_index;

    ///type: 0 is member 1 is array

    unsigned int type;

    bool to_string(std::string* str) const {

        if (type == MEMBER_CODE) {

  Branch (343:13): [True: 0, False: 0]

            str->push_back(BEGIN_MEMBER);

            str->append(leg_ptr, leg_len);

            return true;

        } else if (type == ARRAY_CODE) {

  Branch (347:20): [True: 0, False: 0]

            str->push_back(BEGIN_ARRAY);

            std::string int_str = std::to_string(array_index);

            str->append(int_str);

            str->push_back(END_ARRAY);

            return true;

        } else {

            return false;

        }

    }

};

class JsonbPath {

public:

    // parse json path

    static bool parsePath(Stream* stream, JsonbPath* path);

    static bool parse_array(Stream* stream, JsonbPath* path);

    static bool parse_member(Stream* stream, JsonbPath* path);

    //return true if json path valid else return false

    bool seek(const char* string, size_t length);

    void add_leg_to_leg_vector(std::unique_ptr<leg_info> leg) {

        leg_vector.emplace_back(leg.release());

    }

    void pop_leg_from_leg_vector() { leg_vector.pop_back(); }

    bool to_string(std::string* res) const {

        res->push_back(SCOPE);

        for (const auto& leg : leg_vector) {

  Branch (378:30): [True: 0, False: 0]

            auto valid = leg->to_string(res);

            if (!valid) {

  Branch (380:17): [True: 0, False: 0]

                return false;

            }

        }

        return true;

    }

    size_t get_leg_vector_size() { return leg_vector.size(); }

    leg_info* get_leg_from_leg_vector(size_t i) { return leg_vector[i].get(); }

    void clean() { leg_vector.clear(); }

private:

    std::vector<std::unique_ptr<leg_info>> leg_vector;

};

/*

 * JsonbFwdIteratorT implements JSONB's iterator template.

 *

 * Note: it is an FORWARD iterator only due to the design of JSONB format.

 */

template <class Iter_Type, class Cont_Type>

class JsonbFwdIteratorT {

public:

    using iterator = Iter_Type;

    using pointer = typename std::iterator_traits<Iter_Type>::pointer;

    using reference = typename std::iterator_traits<Iter_Type>::reference;

    explicit JsonbFwdIteratorT() : current_(nullptr) {}

    explicit JsonbFwdIteratorT(const iterator& i) : current_(i) {}

_ZN5doris17JsonbFwdIteratorTIPKNS_13JsonbKeyValueENS_9ObjectValEEC2ERKS3_

Line

Count

Source

410

499k

    explicit JsonbFwdIteratorT(const iterator& i) : current_(i) {}

_ZN5doris17JsonbFwdIteratorTIPKNS_10JsonbValueENS_8ArrayValEEC2ERKS3_

Line

Count

Source

410

621k

    explicit JsonbFwdIteratorT(const iterator& i) : current_(i) {}

_ZN5doris17JsonbFwdIteratorTIPNS_13JsonbKeyValueENS_9ObjectValEEC2ERKS2_

Line

Count

Source

410

17.8k

    explicit JsonbFwdIteratorT(const iterator& i) : current_(i) {}

Unexecuted instantiation: _ZN5doris17JsonbFwdIteratorTIPNS_10JsonbValueENS_8ArrayValEEC2ERKS2_

    // allow non-const to const iterator conversion (same container type)

    template <class Iter_Ty>

    JsonbFwdIteratorT(const JsonbFwdIteratorT<Iter_Ty, Cont_Type>& rhs) : current_(rhs.base()) {}

    bool operator==(const JsonbFwdIteratorT& rhs) const { return (current_ == rhs.current_); }

_ZNK5doris17JsonbFwdIteratorTIPNS_13JsonbKeyValueENS_9ObjectValEEeqERKS4_

Line

Count

Source

416

14.6k

    bool operator==(const JsonbFwdIteratorT& rhs) const { return (current_ == rhs.current_); }

_ZNK5doris17JsonbFwdIteratorTIPKNS_13JsonbKeyValueENS_9ObjectValEEeqERKS5_

Line

Count

Source

416

998k

    bool operator==(const JsonbFwdIteratorT& rhs) const { return (current_ == rhs.current_); }

_ZNK5doris17JsonbFwdIteratorTIPKNS_10JsonbValueENS_8ArrayValEEeqERKS5_

Line

Count

Source

416

7.56M

    bool operator==(const JsonbFwdIteratorT& rhs) const { return (current_ == rhs.current_); }

Unexecuted instantiation: _ZNK5doris17JsonbFwdIteratorTIPNS_10JsonbValueENS_8ArrayValEEeqERKS4_

    bool operator!=(const JsonbFwdIteratorT& rhs) const { return !operator==(rhs); }

_ZNK5doris17JsonbFwdIteratorTIPKNS_13JsonbKeyValueENS_9ObjectValEEneERKS5_

Line

Count

Source

418

749k

    bool operator!=(const JsonbFwdIteratorT& rhs) const { return !operator==(rhs); }

_ZNK5doris17JsonbFwdIteratorTIPKNS_10JsonbValueENS_8ArrayValEEneERKS5_

Line

Count

Source

418

7.25M

    bool operator!=(const JsonbFwdIteratorT& rhs) const { return !operator==(rhs); }

_ZNK5doris17JsonbFwdIteratorTIPNS_13JsonbKeyValueENS_9ObjectValEEneERKS4_

Line

Count

Source

418

14.6k

    bool operator!=(const JsonbFwdIteratorT& rhs) const { return !operator==(rhs); }

Unexecuted instantiation: _ZNK5doris17JsonbFwdIteratorTIPNS_10JsonbValueENS_8ArrayValEEneERKS4_

    bool operator<(const JsonbFwdIteratorT& rhs) const { return (current_ < rhs.current_); }

    bool operator>(const JsonbFwdIteratorT& rhs) const { return !operator<(rhs); }

    JsonbFwdIteratorT& operator++() {

        current_ = (iterator)(((char*)current_) + current_->numPackedBytes());

        return *this;

    }

_ZN5doris17JsonbFwdIteratorTIPKNS_13JsonbKeyValueENS_9ObjectValEEppEv

Line

Count

Source

424

749k

    JsonbFwdIteratorT& operator++() {

425

749k

        current_ = (iterator)(((char*)current_) + current_->numPackedBytes());

426

749k

        return *this;

427

749k

    }

_ZN5doris17JsonbFwdIteratorTIPKNS_10JsonbValueENS_8ArrayValEEppEv

Line

Count

Source

424

3.47M

    JsonbFwdIteratorT& operator++() {

425

3.47M

        current_ = (iterator)(((char*)current_) + current_->numPackedBytes());

426

3.47M

        return *this;

427

3.47M

    }

_ZN5doris17JsonbFwdIteratorTIPNS_13JsonbKeyValueENS_9ObjectValEEppEv

Line

Count

Source

424

11.4k

    JsonbFwdIteratorT& operator++() {

425

11.4k

        current_ = (iterator)(((char*)current_) + current_->numPackedBytes());

426

11.4k

        return *this;

427

11.4k

    }

Unexecuted instantiation: _ZN5doris17JsonbFwdIteratorTIPNS_10JsonbValueENS_8ArrayValEEppEv

    JsonbFwdIteratorT operator++(int) {

        auto tmp = *this;

        current_ = (iterator)(((char*)current_) + current_->numPackedBytes());

        return tmp;

    }

    explicit operator pointer() { return current_; }

    reference operator*() const { return *current_; }

    pointer operator->() const { return current_; }

_ZNK5doris17JsonbFwdIteratorTIPNS_13JsonbKeyValueENS_9ObjectValEEptEv

Line

Count

Source

439

20.6k

    pointer operator->() const { return current_; }

_ZNK5doris17JsonbFwdIteratorTIPKNS_13JsonbKeyValueENS_9ObjectValEEptEv

Line

Count

Source

439

2.96M

    pointer operator->() const { return current_; }

    iterator base() const { return current_; }

private:

    iterator current_;

};

using hDictInsert = int (*)(const char*, unsigned int);

using hDictFind = int (*)(const char*, unsigned int);

using JsonbTypeUnder = std::underlying_type_t<JsonbType>;

/*

 * JsonbKeyValue class defines JSONB key type, as described below.

 *

 * key ::=

 *   0x00 int8    //1-byte dictionary id

 * | int8 (byte*) //int8 (>0) is the size of the key string

 *

 * value ::= primitive_value | container

 *

 * JsonbKeyValue can be either an id mapping to the key string in an external

 * dictionary, or it is the original key string. Whether to read an id or a

 * string is decided by the first byte (size_).

 *

 * Note: a key object must be followed by a value object. Therefore, a key

 * object implicitly refers to a key-value pair, and you can get the value

 * object right after the key object. The function numPackedBytes hence

 * indicates the total size of the key-value pair, so that we will be able go

 * to next pair from the key.

 *

 * ** Dictionary size **

 * By default, the dictionary size is 255 (1-byte). Users can define

 * "USE_LARGE_DICT" to increase the dictionary size to 655535 (2-byte).

 */

class JsonbKeyValue {

public:

    // now we use sMaxKeyId to represent an empty key

    static const int sMaxKeyId = 65535;

    using keyid_type = uint16_t;

    JsonbKeyValue() = delete;

    static const uint8_t sMaxKeyLen = 64;

    // size of the key. 0 indicates it is stored as id

    uint8_t klen() const { return size_; }

    // get the key string. Note the string may not be null terminated.

    const char* getKeyStr() const { return key_.str_; }

    keyid_type getKeyId() const { return key_.id_; }

    unsigned int keyPackedBytes() const {

        return size_ ? (sizeof(size_) + size_) : (sizeof(size_) + sizeof(keyid_type));

  Branch (494:16): [True: 1.43M, False: 85.2k]

    }

    JsonbValue* value() const { return (JsonbValue*)(((char*)this) + keyPackedBytes()); }

    // size of the total packed bytes (key+value)

    unsigned int numPackedBytes() const;

private:

    uint8_t size_;

    union key_ {

        keyid_type id_;

        char str_[1];

    } key_;

};

/*

 * JsonbValue is the base class of all JSONB types. It contains only one member

 * variable - type info, which can be retrieved by member functions is[Type]()

 * or type().

 */

class JsonbValue {

public:

    static const uint32_t sMaxValueLen = 1 << 24; // 16M

    bool isNull() const { return (type_ == JsonbType::T_Null); }

    bool isTrue() const { return (type_ == JsonbType::T_True); }

    bool isFalse() const { return (type_ == JsonbType::T_False); }

    bool isInt() const { return isInt8() || isInt16() || isInt32() || isInt64() || isInt128(); }

  Branch (523:33): [True: 6, False: 79]
  Branch (523:45): [True: 6, False: 73]
  Branch (523:58): [True: 6, False: 67]
  Branch (523:71): [True: 6, False: 61]
  Branch (523:84): [True: 0, False: 61]

    bool isInt8() const { return (type_ == JsonbType::T_Int8); }

    bool isInt16() const { return (type_ == JsonbType::T_Int16); }

    bool isInt32() const { return (type_ == JsonbType::T_Int32); }

    bool isInt64() const { return (type_ == JsonbType::T_Int64); }

    bool isDouble() const { return (type_ == JsonbType::T_Double); }

    bool isFloat() const { return (type_ == JsonbType::T_Float); }

    bool isString() const { return (type_ == JsonbType::T_String); }

    bool isBinary() const { return (type_ == JsonbType::T_Binary); }

    bool isObject() const { return (type_ == JsonbType::T_Object); }

    bool isArray() const { return (type_ == JsonbType::T_Array); }

    bool isInt128() const { return (type_ == JsonbType::T_Int128); }

    JsonbType type() const { return type_; }

    const char* typeName() const {

        switch (type_) {

        case JsonbType::T_Null:

  Branch (540:9): [True: 0, False: 0]

            return "null";

        case JsonbType::T_True:

  Branch (542:9): [True: 0, False: 0]

        case JsonbType::T_False:

  Branch (543:9): [True: 0, False: 0]

            return "bool";

        case JsonbType::T_Int8:

  Branch (545:9): [True: 0, False: 0]

        case JsonbType::T_Int16:

  Branch (546:9): [True: 0, False: 0]

        case JsonbType::T_Int32:

  Branch (547:9): [True: 0, False: 0]

            return "int";

        case JsonbType::T_Int64:

  Branch (549:9): [True: 0, False: 0]

            return "bigint";

        case JsonbType::T_Int128:

  Branch (551:9): [True: 0, False: 0]

            return "largeint";

        case JsonbType::T_Double:

  Branch (553:9): [True: 0, False: 0]

            return "double";

        case JsonbType::T_Float:

  Branch (555:9): [True: 0, False: 0]

            return "float";

        case JsonbType::T_String:

  Branch (557:9): [True: 0, False: 0]

            return "string";

        case JsonbType::T_Binary:

  Branch (559:9): [True: 0, False: 0]

            return "binary";

        case JsonbType::T_Object:

  Branch (561:9): [True: 0, False: 0]

            return "object";

        case JsonbType::T_Array:

  Branch (563:9): [True: 0, False: 0]

            return "array";

        default:

  Branch (565:9): [True: 0, False: 0]

            return "unknown";

        }

    }

    // size of the total packed bytes

    unsigned int numPackedBytes() const;

    // size of the value in bytes

    unsigned int size() const;

    //Get the number of jsonbvalue elements

    int length() const;

    //Whether to include the jsonbvalue rhs

    bool contains(JsonbValue* rhs) const;

    // get the raw byte array of the value

    const char* getValuePtr() const;

    // find the JSONB value by JsonbPath

    JsonbValue* findValue(JsonbPath& path, hDictFind handler);

    friend class JsonbDocument;

protected:

    JsonbType type_; // type info

    JsonbValue();

};

/*

 * NumerValT is the template class (derived from JsonbValue) of all number

 * types (integers and double).

 */

template <class T>

class NumberValT : public JsonbValue {

public:

    T val() const { return num_; }

_ZNK5doris10NumberValTIaE3valEv

Line

Count

Source

602

518

    T val() const { return num_; }

_ZNK5doris10NumberValTIsE3valEv

Line

Count

Source

602

446

    T val() const { return num_; }

_ZNK5doris10NumberValTIiE3valEv

Line

Count

Source

602

3.49k

    T val() const { return num_; }

_ZNK5doris10NumberValTIlE3valEv

Line

Count

Source

602

846k

    T val() const { return num_; }

_ZNK5doris10NumberValTInE3valEv

Line

Count

Source

602

1.02k

    T val() const { return num_; }

_ZNK5doris10NumberValTIdE3valEv

Line

Count

Source

602

765k

    T val() const { return num_; }

Unexecuted instantiation: _ZNK5doris10NumberValTIfE3valEv

    unsigned int numPackedBytes() const { return sizeof(JsonbValue) + sizeof(T); }

    // catch all unknow specialization of the template class

    bool setVal(T value) { return false; }

private:

    T num_;

    NumberValT();

};

using JsonbInt8Val = NumberValT<int8_t>;

// override setVal for Int8Val

template <>

inline bool JsonbInt8Val::setVal(int8_t value) {

    if (!isInt8()) {

        return false;

    }

    num_ = value;

    return true;

}

using JsonbInt16Val = NumberValT<int16_t>;

// override setVal for Int16Val

template <>

inline bool JsonbInt16Val::setVal(int16_t value) {

    if (!isInt16()) {

        return false;

    }

    num_ = value;

    return true;

}

using JsonbInt32Val = NumberValT<int32_t>;

// override setVal for Int32Val

template <>

inline bool JsonbInt32Val::setVal(int32_t value) {

    if (!isInt32()) {

        return false;

    }

    num_ = value;

    return true;

}

using JsonbInt64Val = NumberValT<int64_t>;

// override setVal for Int64Val

template <>

inline bool JsonbInt64Val::setVal(int64_t value) {

    if (!isInt64()) {

        return false;

    }

    num_ = value;

    return true;

}

using JsonbInt128Val = NumberValT<int128_t>;

// override setVal for Int128Val

template <>

inline bool JsonbInt128Val::setVal(int128_t value) {

    if (!isInt128()) {

        return false;

    }

    num_ = value;

    return true;

}

using JsonbDoubleVal = NumberValT<double>;

// override setVal for DoubleVal

template <>

inline bool JsonbDoubleVal::setVal(double value) {

    if (!isDouble()) {

        return false;

    }

    num_ = value;

    return true;

}

using JsonbFloatVal = NumberValT<float>;

// override setVal for DoubleVal

template <>

inline bool JsonbFloatVal::setVal(float value) {

    if (!isFloat()) {

        return false;

    }

    num_ = value;

    return true;

}

// A class to get an integer

class JsonbIntVal : public JsonbValue {

public:

    int128_t val() const {

        switch (type_) {

        case JsonbType::T_Int8:

  Branch (710:9): [True: 30, False: 46]

            return ((JsonbInt8Val*)this)->val();

        case JsonbType::T_Int16:

  Branch (712:9): [True: 24, False: 52]

            return ((JsonbInt16Val*)this)->val();

        case JsonbType::T_Int32:

  Branch (714:9): [True: 12, False: 64]

            return ((JsonbInt32Val*)this)->val();

        case JsonbType::T_Int64:

  Branch (716:9): [True: 10, False: 66]

            return ((JsonbInt64Val*)this)->val();

        case JsonbType::T_Int128:

  Branch (718:9): [True: 0, False: 76]

            return ((JsonbInt128Val*)this)->val();

        default:

  Branch (720:9): [True: 0, False: 76]

            return 0;

        }

    }

    bool setVal(int128_t val) {

        switch (type_) {

        case JsonbType::T_Int8:

            if (val < std::numeric_limits<int8_t>::min() ||

                val > std::numeric_limits<int8_t>::max()) {

                return false;

            }

            return ((JsonbInt8Val*)this)->setVal((int8_t)val);

        case JsonbType::T_Int16:

            if (val < std::numeric_limits<int16_t>::min() ||

                val > std::numeric_limits<int16_t>::max()) {

                return false;

            }

            return ((JsonbInt16Val*)this)->setVal((int16_t)val);

        case JsonbType::T_Int32:

            if (val < std::numeric_limits<int32_t>::min() ||

                val > std::numeric_limits<int32_t>::max()) {

                return false;

            }

            return ((JsonbInt32Val*)this)->setVal((int32_t)val);

        case JsonbType::T_Int64:

            return ((JsonbInt64Val*)this)->setVal((int64_t)val);

        case JsonbType::T_Int128:

            return ((JsonbInt128Val*)this)->setVal(val);

        default:

            return false;

        }

    }

};

/*

 * BlobVal is the base class (derived from JsonbValue) for string and binary

 * types. The size_ indicates the total bytes of the payload_.

 */

class JsonbBlobVal : public JsonbValue {

public:

    // size of the blob payload only

    unsigned int getBlobLen() const { return size_; }

    // return the blob as byte array

    const char* getBlob() const { return payload_; }

    // size of the total packed bytes

    unsigned int numPackedBytes() const { return sizeof(JsonbValue) + sizeof(size_) + size_; }

    friend class JsonbDocument;

protected:

    uint32_t size_;

    char payload_[0];

    // set new blob bytes

    bool internalSetVal(const char* blob, uint32_t blobSize) {

        // if we cannot fit the new blob, fail the operation

        if (blobSize > size_) {

            return false;

        }

        memcpy(payload_, blob, blobSize);

        // Set the reset of the bytes to 0.  Note we cannot change the size_ of the

        // current payload, as all values are packed.

        memset(payload_ + blobSize, 0, size_ - blobSize);

        return true;

    }

    JsonbBlobVal();

};

/*

 * Binary type

 */

class JsonbBinaryVal : public JsonbBlobVal {

public:

    bool setVal(const char* blob, uint32_t blobSize) {

        if (!isBinary()) {

            return false;

        }

        return internalSetVal(blob, blobSize);

    }

private:

    JsonbBinaryVal();

};

/*

 * String type

 * Note: JSONB string may not be a c-string (NULL-terminated)

 */

class JsonbStringVal : public JsonbBlobVal {

public:

    bool setVal(const char* str, uint32_t blobSize) {

        if (!isString()) {

            return false;

        }

        return internalSetVal(str, blobSize);

    }

    /*

    This function return the actual size of a string. Since for

    a string, it can be null-terminated with null paddings or it

    can take all the space in the payload_ without null in the end.

    So we need to check it to get the true actual length of a string.

  */

    size_t length() {

        // It's an empty string

        if (0 == size_) {

  Branch (831:13): [True: 143k, False: 1.81M]

            return size_;

        }

        // The string stored takes all the spaces in payload_

        if (payload_[size_ - 1] != 0) {

  Branch (835:13): [True: 1.81M, False: 0]

            return size_;

        }

        // It's shorter than the size of payload_

        return strnlen(payload_, size_);

    }

    // convert the string (case insensitive) to a boolean value

    // "false": 0

    // "true": 1

    // all other strings: -1

    int getBoolVal() {

        if (size_ == 4 && tolower(payload_[0]) == 't' && tolower(payload_[1]) == 'r' &&

            tolower(payload_[2]) == 'u' && tolower(payload_[3]) == 'e') {

            return 1;

        } else if (size_ == 5 && tolower(payload_[0]) == 'f' && tolower(payload_[1]) == 'a' &&

                   tolower(payload_[2]) == 'l' && tolower(payload_[3]) == 's' &&

                   tolower(payload_[4]) == 'e') {

            return 0;

        } else {

            return -1;

        }

    }

private:

    JsonbStringVal();

};

/*

 * ContainerVal is the base class (derived from JsonbValue) for object and

 * array types. The size_ indicates the total bytes of the payload_.

 */

class ContainerVal : public JsonbValue {

public:

    // size of the container payload only

    unsigned int getContainerSize() const { return size_; }

    // return the container payload as byte array

    const char* getPayload() const { return payload_; }

    // size of the total packed bytes

    unsigned int numPackedBytes() const { return sizeof(JsonbValue) + sizeof(size_) + size_; }

    friend class JsonbDocument;

protected:

    uint32_t size_;

    char payload_[0];

    ContainerVal();

};

/*

 * Object type

 */

class ObjectVal : public ContainerVal {

public:

    using value_type = JsonbKeyValue;

    using pointer = value_type*;

    using const_pointer = const value_type*;

    using iterator = JsonbFwdIteratorT<pointer, ObjectVal>;

    using const_iterator = JsonbFwdIteratorT<const_pointer, ObjectVal>;

    const_iterator search(const char* key, hDictFind handler = nullptr) const {

        return const_cast<ObjectVal*>(this)->search(key, handler);

    }

    const_iterator search(const char* key, unsigned int klen, hDictFind handler = nullptr) const {

        return const_cast<ObjectVal*>(this)->search(key, klen, handler);

    }

    const_iterator search(int key_id) const { return const_cast<ObjectVal*>(this)->search(key_id); }

    iterator search(const char* key, hDictFind handler = nullptr) {

        if (!key) {

            return end();

        }

        return search(key, (unsigned int)strlen(key), handler);

    }

    iterator search(const char* key, unsigned int klen, hDictFind handler = nullptr) {

        if (!key || !klen) {

  Branch (913:13): [True: 0, False: 51]
  Branch (913:21): [True: 0, False: 51]

            return end();

        }

        int key_id = -1;

        if (handler && (key_id = handler(key, klen)) >= 0) {

  Branch (918:13): [True: 0, False: 51]
  Branch (918:24): [True: 0, False: 0]

            return search(key_id);

        }

        return internalSearch(key, klen);

    }

    iterator search(int key_id) {

        if (key_id < 0 || key_id > JsonbKeyValue::sMaxKeyId) {