Exemplos de netstr_tstr_serialized_len_cb em C++ (Cpp)

Exemplo n.º 1

Arquivo: netstr.c Projeto: Inubashiri/PDFLibNet

int netstr_tstr_serialize(const TCHAR *str, TCHAR **buf_ptr, size_t *buf_len_cb_ptr)
{
    char *  buf;
    size_t  buf_len_cb;
    size_t  len_needed_cb;
    TCHAR * num_str;
    size_t  str_len_cch;
    size_t  len_cb;
    size_t  total_len_cb = 0;

    assert(buf_len_cb_ptr);
    if (!buf_len_cb_ptr)
        return FALSE;

    if (!buf_ptr)
    {
        *buf_len_cb_ptr += netstr_tstr_serialized_len_cb(str);
        return TRUE;
    }

    buf = (char*)*buf_ptr;
    assert(buf);
    if (!buf)
        return FALSE;

    buf_len_cb = *buf_len_cb_ptr;
    assert(buf_len_cb > 0);
    if (buf_len_cb <= 0)
        return FALSE;

    len_needed_cb = netstr_tstr_serialized_len_cb(str);
    if (len_needed_cb > buf_len_cb)
        return FALSE;

    str_len_cch = tstr_len(str);
    num_str = tstr_printf(_T("%d:"), str_len_cch);
    if (!num_str)
        return FALSE;

    len_cb = tstr_len(num_str)*sizeof(TCHAR);
    memcpy(buf, num_str, len_cb);
    buf += len_cb;
    total_len_cb += len_cb;
    assert(total_len_cb <= len_needed_cb);
    len_cb = tstr_len(str)*sizeof(TCHAR);
    memcpy(buf, str, len_cb);
    buf += len_cb;
    total_len_cb += len_cb;
    assert(total_len_cb <= len_needed_cb);
    len_cb = sizeof(TCHAR);
    memcpy(buf, _T(","), len_cb);
    buf += len_cb;
    total_len_cb += len_cb;
    assert(total_len_cb == len_needed_cb);

    *buf_len_cb_ptr -= total_len_cb;
    *buf_ptr = (TCHAR*)buf;
    free((void*)num_str);
    return TRUE;
}

Exemplo n.º 2

Arquivo: prefs_util.c Projeto: wzhsunn/SumatraPDF_0.6_Source

/* Serialize 'pref' to a buffer 'buf_ptr' of size 'buf_len_cb_ptr'.
   Return TRUE if ok, FALSE if failed (e.g. buffer is not large enough).
   If 'buf_ptr' is NULL, returns desired size in 'buf_len_cb_ptr'.
   */
static int prefs_serialize_pref(prefs_data *pref, TCHAR **buf_ptr, size_t *buf_len_cb_ptr)
{
    size_t  len_cb;
    TCHAR * name_with_type;
    int     f_ok;

    assert(pref);
    assert(pref->name);
    assert(pref_type_valid(pref->type));
    assert(buf_len_cb_ptr);

    if (!buf_ptr) {
        len_cb  = netstr_tstrn_serialized_len_cb(TYPE_PREFIX_CCH_LEN + tstr_len(pref->name));
        if (PT_INT == pref->type)
            len_cb += netstr_int_serialized_len_cb(*pref->data.data_int);
        else if (PT_STRING == pref->type)
            len_cb += netstr_tstr_serialized_len_cb(*pref->data.data_str);
        else
            assert(0);
        *buf_len_cb_ptr = len_cb;
        return TRUE;
    }

    name_with_type = pref_tstr_with_type(pref->name, pref->type);
    if (!name_with_type) return FALSE;
    f_ok = netstr_tstr_serialize(name_with_type, buf_ptr, buf_len_cb_ptr);
    free((void*)name_with_type);
    if (!f_ok) 
        return FALSE;

    if (PT_INT == pref->type)
        f_ok = netstr_int_serialize(*pref->data.data_int, buf_ptr, buf_len_cb_ptr);
    else if (PT_STRING == pref->type)
        f_ok = netstr_tstr_serialize(*pref->data.data_str, buf_ptr, buf_len_cb_ptr);
    else
        assert(0);

    if (!f_ok)
        return FALSE;

    return TRUE;
}