static tb_object_ref_t tb_object_dictionary_copy(tb_object_ref_t object)
{
// check
tb_object_dictionary_t* dictionary = tb_object_dictionary_cast(object);
tb_assert_and_check_return_val(dictionary, tb_null);
// init copy
tb_object_dictionary_t* copy = (tb_object_dictionary_t*)tb_object_dictionary_init(dictionary->size, dictionary->incr);
tb_assert_and_check_return_val(copy, tb_null);
// walk copy
tb_for_all (tb_object_dictionary_item_t*, item, tb_object_dictionary_itor((tb_object_ref_t)dictionary))
{
if (item && item->key)
{
// refn++
if (item->val) tb_object_retain(item->val);
// copy
tb_object_dictionary_insert((tb_object_ref_t)copy, item->key, item->val);
}
}
// ok
return (tb_object_ref_t)copy;
}
static tb_object_ref_t tb_object_bplist_reader_func_dictionary(tb_object_bplist_reader_t* reader, tb_size_t type, tb_size_t size, tb_size_t item_size)
{
// check
tb_assert_and_check_return_val(reader && reader->stream, tb_null);
// init
tb_object_ref_t object = tb_null;
// size is too large?
if (size == 0x0f)
{
// read size
tb_long_t val = tb_object_bplist_reader_func_size(reader, item_size);
tb_assert_and_check_return_val(val >= 0, tb_null);
size = (tb_size_t)val;
}
// init dictionary
object = tb_object_dictionary_init(TB_OBJECT_DICTIONARY_SIZE_MICRO, tb_false);
tb_assert_and_check_return_val(object, tb_null);
// init items data
if (size)
{
item_size <<= 1;
tb_byte_t* data = tb_malloc_bytes(sizeof(tb_uint32_t) + (size * item_size));
if (data)
{
if (tb_stream_bread(reader->stream, data + sizeof(tb_uint32_t), size * item_size))
{
tb_bits_set_u32_ne(data, (tb_uint32_t)size);
tb_object_setp(object, data);
}
else tb_free(data);
}
}
// ok?
return object;
}
static tb_object_ref_t tb_object_json_reader_func_dictionary(tb_object_json_reader_t* reader, tb_char_t type)
{
// check
tb_assert_and_check_return_val(reader && reader->stream && type == '{', tb_null);
// init key name
tb_static_string_t kname;
tb_char_t kdata[8192];
if (!tb_static_string_init(&kname, kdata, 8192)) return tb_null;
// init dictionary
tb_object_ref_t dictionary = tb_object_dictionary_init(0, tb_false);
tb_assert_and_check_return_val(dictionary, tb_null);
// walk
tb_char_t ch;
tb_bool_t ok = tb_true;
tb_bool_t bkey = tb_false;
tb_size_t bstr = 0;
while (ok && tb_stream_left(reader->stream))
{
// read one character
ch = tb_stream_bread_s8(reader->stream);
// end?
if (ch == '}') break;
// no space? skip ','
else if (!tb_isspace(ch) && ch != ',')
{
// no key?
if (!bkey)
{
// is str?
if (ch == '\"' || ch == '\'') bstr = !bstr;
// is key end?
else if (!bstr && ch == ':') bkey = tb_true;
// append key
else if (bstr) tb_static_string_chrcat(&kname, ch);
}
// key ok? read val
else
{
// trace
tb_trace_d("key: %s", tb_static_string_cstr(&kname));
// the func
tb_object_json_reader_func_t func = tb_object_json_reader_func(ch);
tb_assert_and_check_break_state(func, ok, tb_false);
// read val
tb_object_ref_t val = func(reader, ch);
tb_assert_and_check_break_state(val, ok, tb_false);
// set key => val
tb_object_dictionary_insert(dictionary, tb_static_string_cstr(&kname), val);
// reset key
bstr = 0;
bkey = tb_false;
tb_static_string_clear(&kname);
}
}
}
// failed?
if (!ok)
{
// exit it
if (dictionary) tb_object_exit(dictionary);
dictionary = tb_null;
}
// exit key name
tb_static_string_exit(&kname);
// ok?
return dictionary;
}
static tb_object_ref_t tb_object_xplist_reader_func_dictionary(tb_object_xplist_reader_t* reader, tb_size_t event)
{
// check
tb_assert_and_check_return_val(reader && reader->reader && event, tb_null);
// empty?
if (event == TB_XML_READER_EVENT_ELEMENT_EMPTY)
return tb_object_dictionary_init(TB_OBJECT_DICTIONARY_SIZE_MICRO, tb_false);
// init key name
tb_static_string_t kname;
tb_char_t kdata[8192];
if (!tb_static_string_init(&kname, kdata, 8192)) return tb_null;
// init dictionary
tb_object_ref_t dictionary = tb_object_dictionary_init(0, tb_false);
tb_assert_and_check_return_val(dictionary, tb_null);
// done
tb_long_t ok = 0;
tb_bool_t key = tb_false;
while (!ok && (event = tb_xml_reader_next(reader->reader)))
{
switch (event)
{
case TB_XML_READER_EVENT_ELEMENT_BEG:
case TB_XML_READER_EVENT_ELEMENT_EMPTY:
{
// name
tb_char_t const* name = tb_xml_reader_element(reader->reader);
tb_assert_and_check_break_state(name, ok, -1);
tb_trace_d("%s", name);
// is key
if (!tb_stricmp(name, "key")) key = tb_true;
else if (!key)
{
// func
tb_object_xplist_reader_func_t func = tb_object_xplist_reader_func(name);
tb_assert_and_check_break_state(func, ok, -1);
// read
tb_object_ref_t object = func(reader, event);
tb_trace_d("%s => %p", tb_static_string_cstr(&kname), object);
tb_assert_and_check_break_state(object, ok, -1);
// set key & value
if (tb_static_string_size(&kname) && dictionary)
tb_object_dictionary_insert(dictionary, tb_static_string_cstr(&kname), object);
// clear key name
tb_static_string_clear(&kname);
}
}
break;
case TB_XML_READER_EVENT_ELEMENT_END:
{
// name
tb_char_t const* name = tb_xml_reader_element(reader->reader);
tb_assert_and_check_break_state(name, ok, -1);
// is end?
if (!tb_stricmp(name, "dict")) ok = 1;
else if (!tb_stricmp(name, "key")) key = tb_false;
}
break;
case TB_XML_READER_EVENT_TEXT:
{
if (key)
{
// text
tb_char_t const* text = tb_xml_reader_text(reader->reader);
tb_assert_and_check_break_state(text, ok, -1);
// writ key name
tb_static_string_cstrcpy(&kname, text);
}
}
break;
default:
break;
}
}
// failed
if (ok < 0)
{
// exit it
if (dictionary) tb_object_exit(dictionary);
dictionary = tb_null;
}
// exit key name
tb_static_string_exit(&kname);
// ok?
return dictionary;
}
static tb_object_ref_t tb_object_bin_reader_func_dictionary(tb_object_bin_reader_t* reader, tb_size_t type, tb_uint64_t size)
{
// check
tb_assert_and_check_return_val(reader && reader->stream && reader->list, tb_null);
// empty?
if (!size) return tb_object_dictionary_init(TB_OBJECT_DICTIONARY_SIZE_MICRO, tb_false);
// init dictionary
tb_object_ref_t dictionary = tb_object_dictionary_init(0, tb_false);
tb_assert_and_check_return_val(dictionary, tb_null);
// walk
tb_size_t i = 0;
tb_size_t n = (tb_size_t)size;
for (i = 0; i < n; i++)
{
// read key
tb_object_ref_t key = tb_null;
do
{
// the type & size
tb_size_t type = 0;
tb_uint64_t size = 0;
tb_object_reader_bin_type_size(reader->stream, &type, &size);
// trace
tb_trace_d("key: type: %lu, size: %llu", type, size);
// is index?
if (!type)
{
// the object index
tb_size_t index = (tb_size_t)size;
// check
tb_assert_and_check_break(index < tb_vector_size(reader->list));
// the item
key = (tb_object_ref_t)tb_iterator_item(reader->list, index);
}
else
{
// check
tb_assert_and_check_break(type == TB_OBJECT_TYPE_STRING);
// the reader func
tb_object_bin_reader_func_t func = tb_object_bin_reader_func(type);
tb_assert_and_check_break(func);
// read it
key = func(reader, type, size);
tb_assert_and_check_break(key);
// save it
tb_vector_insert_tail(reader->list, key);
// refn--
tb_object_dec(key);
}
} while (0);
// check
tb_assert_and_check_break(key && tb_object_type(key) == TB_OBJECT_TYPE_STRING);
tb_assert_and_check_break(tb_object_string_size(key) && tb_object_string_cstr(key));
// read val
tb_object_ref_t val = tb_null;
do
{
// the type & size
tb_size_t type = 0;
tb_uint64_t size = 0;
tb_object_reader_bin_type_size(reader->stream, &type, &size);
// trace
tb_trace_d("val: type: %lu, size: %llu", type, size);
// is index?
if (!type)
{
// the object index
tb_size_t index = (tb_size_t)size;
// check
tb_assert_and_check_break(index < tb_vector_size(reader->list));
// the item
val = (tb_object_ref_t)tb_iterator_item(reader->list, index);
// refn++
if (val) tb_object_inc(val);
}
else
{
// the reader func
tb_object_bin_reader_func_t func = tb_object_bin_reader_func(type);
tb_assert_and_check_break(func);
// read it
val = func(reader, type, size);
// save it
if (val) tb_vector_insert_tail(reader->list, val);
}
} while (0);
// check
tb_assert_and_check_break(val);
// set key => val
tb_object_dictionary_set(dictionary, tb_object_string_cstr(key), val);
}
// failed?
if (i != n)
{
if (dictionary) tb_object_exit(dictionary);
dictionary = tb_null;
}
// ok?
return dictionary;
}
