C++ (Cpp) fs_stream_write_int32 Examples

Example #1

File: rb_define.c Project: Passerby/fsnet

size_t
fs_ruby_pack_to_data( struct fs_server* server, struct fs_pack* pack, BYTE** out){
    
    
    
    BYTE* data = NULL;
    size_t len = 0;
    if(pack->data_output_stream_id != Qnil){
        struct fs_output_stream* os = NULL;
        Data_Get_Struct(pack->data_output_stream_id, struct fs_output_stream, os);
        
        data = (BYTE*)fs_output_stream_get_dataptr(os);
        len = fs_output_stream_get_len(os);
        
    }
    
    if(pack->data_input_stream_id != Qnil){
        struct fs_input_stream* is = NULL;
        Data_Get_Struct(pack->data_input_stream_id, struct fs_input_stream, is);
        
        
        data = (BYTE*)fs_input_stream_get_data_ptr(is);
        len = fs_input_stream_get_len(is);
        
    }
    
    
    if (pack->input_stream != NULL) {
        data = (BYTE*)fs_input_stream_get_data_ptr(pack->input_stream);
        len = fs_input_stream_get_len(pack->input_stream);
    }
    
    
    VALUE c_server = fs_server_get_script_id(server);
    VALUE byte_order = rb_funcall(c_server, rb_intern("byte_order"), 0);
    
    
    struct fs_output_stream* fos = fs_create_output_stream_ext;
    fs_stream_write_byte(fos, FIX2INT(byte_order));
    fs_stream_write_int32(fos, (int32_t)len + pack_head_len);
    fs_stream_write_data(fos, data, len);
    
    size_t ret_len = fs_output_stream_get_len(fos);
    
    *out = fs_malloc(ret_len);
    memcpy(*out, fs_output_stream_get_dataptr(fos), ret_len);
    
    fs_stream_free_output(fos);
    
    if(len == 0){
        rb_raise(rb_eRuntimeError, "try send data len for 0");
    }
    
    return ret_len;
}

Example #2

File: FSParams.cpp Project: frodosens/fsnet

void FSParams::write_to_stream(struct fs_output_stream* os, fs_bool write_head){
    
    if(write_head){
        fs_stream_write_byte(os, type_array ? PARAMS_TYPE_ARRAY : PARAMS_TYPE_DOUCMENT);
    }
    fs_stream_write_int16(os, size());
    FSParams::params_iterate iter;
    
    for(iter = begin() ; iter != end() ; iter++){
        
        params_type type = (*iter)->type;
        
        if(type_hash){
            fs_stream_write_string(os, (*iter)->key, strlen( (*iter)->key ));
        }
        
        switch (type) {
            case PARAMS_TYPE_INT:
                fs_stream_write_byte(os, PARAMS_TYPE_INT);
                fs_stream_write_int32(os,  get<int>( (*iter)->key ) );
                break;
            case PARAMS_TYPE_ARRAY:
                get<FSParams*>( (*iter)->key )->write_to_stream(os);
                break;
            case PARAMS_TYPE_BOOL:
                fs_stream_write_byte(os, PARAMS_TYPE_BOOL);
                fs_stream_write_byte(os,  get<bool>( (*iter)->key ) ? 1 : 0 );
                break;
            case PARAMS_TYPE_DOUBLE:
                fs_stream_write_byte(os, PARAMS_TYPE_DOUBLE);
                fs_stream_write_double(os,  get<double>( (*iter)->key ) );
                break;
            case PARAMS_TYPE_DOUCMENT:
                fs_stream_write_byte(os, PARAMS_TYPE_DOUCMENT);
                get<FSParams*>( (*iter)->key )->write_to_stream(os);
                break;
            case PARAMS_TYPE_INT64:
                fs_stream_write_byte(os, PARAMS_TYPE_INT64);
                fs_stream_write_int64(os,  get<long long>( (*iter)->key ) );
                break;
            case PARAMS_TYPE_UTF8:
                fs_stream_write_byte(os, PARAMS_TYPE_UTF8);
                fs_stream_write_string(os, get<const char*>( (*iter)->key ), strlen(  get<const char*>( (*iter)->key ) ));
                break;
            case PARAMS_TYPE_NULL:
                fs_stream_write_byte(os, PARAMS_TYPE_NULL);
                break;
            default:
                break;
        }
        
    }
    
}