tb_object_ref_t tb_object_data(tb_object_ref_t object, tb_size_t format)
{
// check
tb_assert_and_check_return_val(object, tb_null);
// done
tb_object_ref_t odata = tb_null;
tb_size_t maxn = 4096;
tb_byte_t* data = tb_null;
do
{
// make data
data = data? (tb_byte_t*)tb_ralloc(data, maxn) : tb_malloc_bytes(maxn);
tb_assert_and_check_break(data);
// writ object to data
tb_long_t size = tb_object_writ_to_data(object, data, maxn, format);
// ok? make the data object
if (size >= 0) odata = tb_object_data_init_from_data(data, size);
// failed? grow it
else maxn <<= 1;
} while (!odata);
// exit data
if (data) tb_free(data);
data = tb_null;
// ok?
return odata;
}
/* //////////////////////////////////////////////////////////////////////////////////////
* interfaces
*/
tb_object_ref_t tb_object_data_init_from_url(tb_char_t const* url)
{
// check
tb_assert_and_check_return_val(url, tb_null);
// init stream
tb_stream_ref_t stream = tb_stream_init_from_url(url);
tb_assert_and_check_return_val(stream, tb_null);
// make stream
tb_object_ref_t object = tb_null;
if (tb_stream_open(stream))
{
// read all data
tb_size_t size = 0;
tb_byte_t* data = (tb_byte_t*)tb_stream_bread_all(stream, tb_false, &size);
if (data)
{
// make object
object = tb_object_data_init_from_data(data, size);
// exit data
tb_free(data);
}
// exit stream
tb_stream_exit(stream);
}
// ok?
return object;
}
/* //////////////////////////////////////////////////////////////////////////////////////
* interfaces
*/
tb_object_ref_t tb_object_data_init_from_url(tb_char_t const* url)
{
// check
tb_assert_and_check_return_val(url, tb_null);
// init stream
tb_stream_ref_t stream = tb_stream_init_from_url(url);
tb_assert_and_check_return_val(stream, tb_null);
// make stream
tb_object_ref_t object = tb_null;
if (tb_stream_open(stream))
{
// size
tb_hong_t size = tb_stream_size(stream);
if (size > 0 && size < TB_MAXS32)
{
tb_byte_t* data = tb_malloc0_bytes((tb_size_t)size);
if (data)
{
if (tb_stream_bread(stream, data, (tb_size_t)size))
object = tb_object_data_init_from_data(data, (tb_size_t)size);
tb_free(data);
}
}
else object = tb_object_data_init_from_data(tb_null, 0);
// check, TODO: read stream if no size
tb_assert(size >= 0 && size < TB_MAXS32);
// exit stream
tb_stream_exit(stream);
}
// ok?
return object;
}
static tb_object_ref_t tb_object_bplist_reader_func_data(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_byte_t* data = tb_null;
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;
}
// no empty?
if (size)
{
// make data
data = tb_malloc_bytes(size);
tb_assert_and_check_return_val(data, tb_null);
// read data
if (tb_stream_bread(reader->stream, data, size))
object = tb_object_data_init_from_data(data, size);
}
else object = tb_object_data_init_from_data(tb_null, 0);
// exit
if (data) tb_free(data);
// ok?
return object;
}
static tb_object_ref_t tb_object_bin_reader_func_data(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_data_init_from_data(tb_null, 0);
// make data
tb_char_t* data = tb_malloc0_cstr((tb_size_t)size);
tb_assert_and_check_return_val(data, tb_null);
// read data
if (!tb_stream_bread(reader->stream, (tb_byte_t*)data, (tb_size_t)size))
{
tb_free(data);
return tb_null;
}
// decode data
{
tb_byte_t* pb = (tb_byte_t*)data;
tb_byte_t* pe = (tb_byte_t*)data + size;
tb_byte_t xb = (tb_byte_t)(((size >> 8) & 0xff) | (size & 0xff));
for (; pb < pe; pb++, xb++) *pb ^= xb;
}
// make the data object
tb_object_ref_t object = tb_object_data_init_from_data(data, (tb_size_t)size);
// exit data
tb_free(data);
// ok?
return object;
}
static tb_object_ref_t tb_object_xplist_reader_func_data(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_data_init_from_data(tb_null, 0);
// done
tb_bool_t leave = tb_false;
tb_char_t* base64 = tb_null;
tb_object_ref_t data = tb_null;
while (!leave && (event = tb_xml_reader_next(reader->reader)))
{
switch (event)
{
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, leave, tb_true);
// is end?
if (!tb_stricmp(name, "data"))
{
// empty?
if (!data) data = tb_object_data_init_from_data(tb_null, 0);
// leave it
leave = tb_true;
}
}
break;
case TB_XML_READER_EVENT_TEXT:
{
// text
tb_char_t const* text = tb_xml_reader_text(reader->reader);
tb_assert_and_check_break_state(text, leave, tb_true);
tb_trace_d("data: %s", text);
// base64
base64 = tb_strdup(text);
tb_char_t* p = base64;
tb_char_t* q = p;
for (; *p; p++) if (!tb_isspace(*p)) *q++ = *p;
*q = '\0';
// decode base64 data
tb_char_t const* ib = base64;
tb_size_t in = tb_strlen(base64);
if (in)
{
tb_size_t on = in;
tb_byte_t* ob = tb_malloc0_bytes(on);
tb_assert_and_check_break_state(ob && on, leave, tb_true);
on = tb_base64_decode(ib, in, ob, on);
tb_trace_d("base64: %u => %u", in, on);
// init data
data = tb_object_data_init_from_data(ob, on); tb_free(ob);
}
else data = tb_object_data_init_from_data(tb_null, 0);
tb_assert_and_check_break_state(data, leave, tb_true);
}
break;
default:
break;
}
}
// free
if (base64) tb_free(base64);
// ok?
return data;
}
static tb_object_ref_t tb_object_data_copy(tb_object_ref_t object)
{
return tb_object_data_init_from_data(tb_object_data_getp(object), tb_object_data_size(object));
}
