skjson::Value Class Reference

#include <SkJSON.h>

Inheritance diagram for skjson::Value:

Public Types
enum class	Type {   kNull , kBool , kNumber , kString ,   kArray , kObject }

Public Member Functions
Type	getType () const
template<typename T >
bool	is () const
template<typename T >
const T &	as () const
template<typename T >
	operator const T * () const
SkString	toString () const
const Value &	operator[] (const char *key) const

Protected Types
enum class	Tag : uint8_t {   kShortString = 0b00000000 , kNull = 0b00000001 , kBool = 0b00000010 , kInt = 0b00000011 ,   kFloat = 0b00000100 , kString = 0b00000101 , kArray = 0b00000110 , kObject = 0b00000111 }

Protected Member Functions
void	init_tagged (Tag)
void	init_tagged_pointer (Tag, void *)
Tag	getTag () const
template<typename T >
const T *	cast () const
template<typename T >
T *	cast ()
template<typename T >
const T *	ptr () const

Static Protected Attributes
static constexpr uint8_t	kTagMask = 0b00000111

Detailed Description

A fast and likely non-conforming JSON parser.

Some known limitations/compromises:

– single-precision FP numbers

– missing string unescaping (no current users, could be easily added)

Values are opaque, fixed-size (64 bits), immutable records.

They can be converted to facade types for type-specific functionality.

E.g.:

if (v.is<ArrayValue>()) { for (const auto& item : v.as<ArrayValue>()) { if (const NumberValue* n = item) { printf("Found number: %f", **n); } } }

if (v.is<ObjectValue>()) { const StringValue* id = v.as<ObjectValue>()["id"]; if (id) { printf("Found object ID: %s", id->begin()); } else { printf("Missing object ID"); } }

Definition at line 57 of file SkJSON.h.

Member Enumeration Documentation

Tag

enum class skjson::Value::Tag : uint8_t

strongprotected

Enumerator
kShortString
kNull
kBool
kInt
kFloat
kString
kArray
kObject

Definition at line 131 of file SkJSON.h.

                   : uint8_t {
        // n.b.: we picked kShortString == 0 on purpose,
        // to enable certain short-string optimizations.
        kShortString                  = 0b00000000,  // inline payload
        kNull                         = 0b00000001,  // no payload
        kBool                         = 0b00000010,  // inline payload
        kInt                          = 0b00000011,  // inline payload
        kFloat                        = 0b00000100,  // inline payload
        kString                       = 0b00000101,  // ptr to external storage
        kArray                        = 0b00000110,  // ptr to external storage
        kObject                       = 0b00000111,  // ptr to external storage
    };

Type

enum class skjson::Value::Type

strong

Enumerator
kNull
kBool
kNumber
kString
kArray
kObject

Definition at line 59 of file SkJSON.h.

                    {
        kNull,
        kBool,
        kNumber,
        kString,
        kArray,
        kObject,
    };

Member Function Documentation

as()

template<typename T >

const T & skjson::Value::as ( ) const

inline

Unguarded conversion to facade types.

Returns

The record cast as facade type T&.

Definition at line 85 of file SkJSON.h.

                        {
        SkASSERT(this->is<T>());
        return *reinterpret_cast<const T*>(this);
    }

cast() [1/2]

template<typename T >

T * skjson::Value::cast ( )

inlineprotected

Definition at line 194 of file SkJSON.h.

{ return const_cast<T*>(const_cast<const Value*>(this)->cast<T>()); }

cast() [2/2]

template<typename T >

const T * skjson::Value::cast ( ) const

inlineprotected

Definition at line 184 of file SkJSON.h.

                          {
        static_assert(sizeof (T) <=  sizeof(Value), "");
        static_assert(alignof(T) <= alignof(Value), "");
 
        return (sizeof(T) > sizeof(*this) / 2)
                ? reinterpret_cast<const T*>(this) + 0  // need all the bits
                : reinterpret_cast<const T*>(this) + 1; // skip the first word (where the tag lives)
    }

getTag()

Tag skjson::Value::getTag ( ) const

inlineprotected

Definition at line 148 of file SkJSON.h.

                       {
        return static_cast<Tag>(fData8[0] & kTagMask);
    }

getType()

Value::Type Value::getType ( ) const

inline

Returns

The type of this value.

Definition at line 371 of file SkJSON.h.

                                      {
    switch (this->getTag()) {
    case Tag::kNull:        return Type::kNull;
    case Tag::kBool:        return Type::kBool;
    case Tag::kInt:         return Type::kNumber;
    case Tag::kFloat:       return Type::kNumber;
    case Tag::kShortString: return Type::kString;
    case Tag::kString:      return Type::kString;
    case Tag::kArray:       return Type::kArray;
    case Tag::kObject:      return Type::kObject;
    }
 
    SkASSERT(false); // unreachable
    return Type::kNull;
}

init_tagged()

void Value::init_tagged ( Tag  t )

protected

Definition at line 38 of file SkJSON.cpp.

                             {
    memset(fData8, 0, sizeof(fData8));
    fData8[0] = SkTo<uint8_t>(t);
    SkASSERT(this->getTag() == t);
}

init_tagged_pointer()

void Value::init_tagged_pointer ( Tag  t, void *  p  )

protected

Definition at line 45 of file SkJSON.cpp.

                                              {
    if (sizeof(Value) == sizeof(uintptr_t)) {
        *this->cast<uintptr_t>() = reinterpret_cast<uintptr_t>(p);
        // For 64-bit, we rely on the pointer lower bits being zero.
        SkASSERT(!(fData8[0] & kTagMask));
        fData8[0] |= SkTo<uint8_t>(t);
    } else {
        // For 32-bit, we store the pointer in the upper word
        SkASSERT(sizeof(Value) == sizeof(uintptr_t) * 2);
        this->init_tagged(t);
        *this->cast<uintptr_t>() = reinterpret_cast<uintptr_t>(p);
    }
 
    SkASSERT(this->getTag()    == t);
    SkASSERT(this->ptr<void>() == p);
}

is()

template<typename T >

bool skjson::Value::is ( ) const

inline

Returns

True if the record matches the facade type T.

Definition at line 77 of file SkJSON.h.

{ return this->getType() == T::kType; }

operator const T *()

template<typename T >

skjson::Value::operator const T * ( ) const

inline

Guarded conversion to facade types.

Returns

The record cast as facade type T*.

Definition at line 96 of file SkJSON.h.

                              {
        return this->is<T>() ? &this->as<T>() : nullptr;
    }

operator[]()

const Value & Value::operator[] ( const char *  key ) const

inline

Helper for fluent key lookup: v["foo"]["bar"]["baz"]

Returns

The lookup result value on success, otherwise NullValue.

Definition at line 387 of file SkJSON.h.

                                                           {
    static const Value gNullValue = NullValue();
 
    return this->is<ObjectValue>()
        ? this->as<ObjectValue>()[key]
        : gNullValue;
}

ptr()

template<typename T >

const T * skjson::Value::ptr ( ) const

inlineprotected

Definition at line 198 of file SkJSON.h.

                         {
        static_assert(sizeof(uintptr_t)     == sizeof(Value) ||
                      sizeof(uintptr_t) * 2 == sizeof(Value), "");
 
        return (sizeof(uintptr_t) < sizeof(Value))
            // For 32-bit, pointers are stored unmodified.
            ? *this->cast<const T*>()
            // For 64-bit, we use the lower bits of the pointer as tag storage.
            : reinterpret_cast<T*>(*this->cast<uintptr_t>() & ~static_cast<uintptr_t>(kTagMask));
    }

toString()

SkString Value::toString

(

)

const

Returns

The string representation of this value.

Definition at line 938 of file SkJSON.cpp.

                               {
    SkDynamicMemoryWStream wstream;
    Write(*this, &wstream);
    const auto data = wstream.detachAsData();
    // TODO: is there a better way to pass data around without copying?
    return SkString(static_cast<const char*>(data->data()), data->size());
}

Member Data Documentation

kTagMask

constexpr uint8_t skjson::Value::kTagMask = 0b00000111

inlinestaticconstexprprotected

Definition at line 143 of file SkJSON.h.

---

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

• third_party/skia/src/utils/SkJSON.h
• third_party/skia/src/utils/SkJSON.cpp