int users_search(mongo* conn, User* users, int limit) {
int pos = 0;
mongo_cursor cursor[1];
bson_iterator iterator[1];
mongo_cursor_init(cursor, conn, "ruby-mongo-console.users");
// mongo_cursor_set_query
mongo_cursor_set_limit(cursor, limit);
while(mongo_cursor_next(cursor) == MONGO_OK) {
const char* s;
s = get_field_value(iterator, cursor, "name");
if (s) {
users[pos].name_len = strlen(s);
users[pos].name = new_str(s, users[pos].name_len);
} else {
users[pos].name_len = 0;
users[pos].name = NULL;
}
s = get_field_value(iterator, cursor, "bio");
if (s) {
users[pos].bio_len = strlen(s);
users[pos].bio = new_str(s, users[pos].bio_len);
} else {
users[pos].bio_len = 0;
users[pos].bio = NULL;
}
pos++;
}
mongo_cursor_destroy(cursor);
return pos;
}
bool formatter_data_to_keyval(const struct formatter *f,
const uint8_t *data, struct keyval_list *kv_list)
{
unsigned int i;
char buf[80];
bool success = true;
struct keyval kv;
timestamp(f, kv_list);
for (i = 0; i < f->num_fields && success; i++) {
const spt value = get_field_value(&f->fields[i], data);
memset(buf, 0, sizeof(buf));
field_data_to_str(buf, sizeof(buf), value, &f->fields[i]);
kv.key = f->fields[i].name;
kv.value = buf;
success = keyval_list_append(kv_list, &kv);
}
return success;
}
void
add_field (GtkListStore *store, const char *key, const char *title, int is_prop, DB_playItem_t **tracks, int numtracks) {
// get value to edit
const char *mult = is_prop ? "" : _("[Multiple values] ");
char val[MAX_GUI_FIELD_LEN];
size_t ml = strlen (mult);
memcpy (val, mult, ml+1);
int n = get_field_value (val + ml, sizeof (val) - ml, key, deadbeef->pl_find_meta_raw, equals_ptr, tracks, numtracks);
GtkTreeIter iter;
gtk_list_store_append (store, &iter);
if (!is_prop) {
if (n) {
gtk_list_store_set (store, &iter, 0, title, 1, val, 2, key, 3, n ? 1 : 0, -1);
}
else {
deadbeef->pl_lock ();
const char *val = deadbeef->pl_find_meta_raw (tracks[0], key);
if (!val) {
val = "";
}
gtk_list_store_set (store, &iter, 0, title, 1, val, 2, key, 3, n ? 1 : 0, -1);
deadbeef->pl_unlock ();
}
}
else {
gtk_list_store_set (store, &iter, 0, title, 1, n ? val : val + ml, -1);
}
}
const field_value Dataset::get_field_value(const char *f_name) {
if (ds_state != dsInactive)
{
if (ds_state == dsEdit || ds_state == dsInsert){
for (unsigned int i=0; i < edit_object->size(); i++)
if (str_compare((*edit_object)[i].props.name.c_str(), f_name)==0) {
return (*edit_object)[i].val;
}
throw DbErrors("Field not found: %s",f_name);
}
else
{
//Lets try to reuse a string ->index conversation
if (get_index_map_entry(f_name))
return get_field_value(static_cast<int>(fieldIndexMap_Entries[fieldIndexMapID].fieldIndex));
const char* name=strstr(f_name, ".");
if (name)
name++;
for (unsigned int i=0; i < fields_object->size(); i++)
if (str_compare((*fields_object)[i].props.name.c_str(), f_name) == 0 || (name && str_compare((*fields_object)[i].props.name.c_str(), name) == 0)) {
fieldIndexMap_Entries[fieldIndexMapID].fieldIndex = i;
return (*fields_object)[i].val;
}
}
throw DbErrors("Field not found: %s",f_name);
}
throw DbErrors("Dataset state is Inactive");
//field_value fv;
//return fv;
}
int CMySQLConnection::get_field_value(std::string* value, const char* format, ...)
{
va_list args;
va_start(args, format);
utils::VaListHelper vlh(args);
return get_field_value(value, format, args);
}
static VALUE rb_thrift_struct_write(VALUE self, VALUE protocol) {
// call validate
rb_funcall(self, validate_method_id, 0);
// check_native_proto_method_table(protocol);
// write struct begin
mt->write_struct_begin(protocol, rb_class_name(CLASS_OF(self)));
// iterate through all the fields here
VALUE struct_fields = STRUCT_FIELDS(self);
VALUE struct_field_ids_unordered = rb_funcall(struct_fields, keys_method_id, 0);
VALUE struct_field_ids_ordered = rb_funcall(struct_field_ids_unordered, sort_method_id, 0);
int i = 0;
for (i=0; i < RARRAY_LEN(struct_field_ids_ordered); i++) {
VALUE field_id = rb_ary_entry(struct_field_ids_ordered, i);
VALUE field_info = rb_hash_aref(struct_fields, field_id);
VALUE ttype_value = rb_hash_aref(field_info, type_sym);
int ttype = FIX2INT(ttype_value);
VALUE field_name = rb_hash_aref(field_info, name_sym);
VALUE field_value = get_field_value(self, field_name);
if (!NIL_P(field_value)) {
mt->write_field_begin(protocol, field_name, ttype_value, field_id);
write_anything(ttype, field_value, protocol, field_info);
mt->write_field_end(protocol);
}
}
mt->write_field_stop(protocol);
// write struct end
mt->write_struct_end(protocol);
return Qnil;
}
double BGMBase::size(double u, double v, double w)
{
return get_field_value(u, v, w, sizeField);
}
/*
** mexFunction is the interface function to MATLAB.
**
** plhs - pointer to left-hand OUTPUT mxArrays
** nlhs - number of left-hand OUTPUT arrays
** prhs - pointer to right-hand INPUT mxArrays
** nrhs - number of right-hand INPUT arrays
**
*/
void mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[])
{
int msize[]={0,0,0};
int arg_ndims;
int out_dims[]={0,0,0};
buffer *bf_image,*bf_pvec,*bf_pvec2;
ebuffer *bf_elist,*bf_thres=NULL;
buffer *bf_mvec,*bf_mvec2,*bf_arate,*bf_arate2;
buffer *bf_ecdf;
int validcnt,nofedges,rows,cols,ndim;
edgeval d_max;
double d_mean;
mxArray *mx_pvec,*mx_arate,*mx_elist;
int tslist_flag=1;
int min_size=60; /* Default */
double ainc=1.05; /* Default */
double min_marginf=0.0015; /* Default */
edgeval min_margin; /* Value after conversion */
fpnum res=1e-4; /* Default */
int Ns=10; /* Default */
int timesteps=200; /* Default */
int filter_size=3; /* Default */
int n8flag=0; /* Default */
int normfl=1; /* Default */
int blurfl=0; /* Default */
int verbosefl=1; /* Default */
/* Argument count check */
if((nrhs ==0)||(nrhs > 2)) {
mexPrintf("Usage: [<mvec>,<pvec>,<arate>,<elist2>]=detect_mscr(<image>[,<pars>])\n");
if((nrhs > 2))
mexErrMsgTxt("Error: 1 or 2 input arguments required.\n");
return;
}
/* Parse arg 1 (RGB or greyscale image) */
msize[0]=-1;msize[1]=-1;msize[2]=-1;
arg_ndims = mxGetNumberOfDimensions(prhs[0]);
if((arg_ndims!=2)&&(arg_ndims!=3)) {
mexPrintf("Error: <image> should be 2D or 3D.\n");
return;
}
if(!type_check("image",prhs[0],mxDOUBLE_CLASS,arg_ndims,msize))
return;
bf_image=buffer_encapsulate(prhs[0]);
rows = bf_image->rows;
cols = bf_image->cols;
ndim = bf_image->ndim;
if((ndim!=1)&&(ndim!=3)) {
mexPrintf("Size mismatch: <Im> should be MxNxD where D=1 or 3.\n");
free(bf_image);
return;
}
/* Parse arg 2 (pars struct) */
if(nrhs>1) {
msize[0]=1;msize[1]=1;
if(!type_check("pars",prhs[1],mxSTRUCT_CLASS,2,msize)) {
free(bf_image);
return;
}
min_marginf = get_field_value(prhs[1],"min_margin",min_marginf);
min_margin = min_marginf*EDGE_SCALE+EDGE_OFFSET;
timesteps = get_field_value(prhs[1],"timesteps",timesteps);
min_size = get_field_value(prhs[1],"min_size",min_size);
ainc = get_field_value(prhs[1],"ainc",ainc);
filter_size = get_field_value(prhs[1],"filter_size",filter_size);
n8flag = get_field_value(prhs[1],"n8flag",n8flag);
normfl = get_field_value(prhs[1],"normfl",normfl);
blurfl = get_field_value(prhs[1],"blurfl",blurfl);
verbosefl = get_field_value(prhs[1],"verbosefl",verbosefl);
}
if(verbosefl) {
/* Display parameter settings */
mexPrintf("\nDescriptor parameter settings:\n");
mexPrintf(" min_margin: %g\n",min_marginf);
mexPrintf(" timesteps: %d\n",timesteps);
mexPrintf(" min_size: %d\n",min_size);
mexPrintf(" ainc: %g\n",ainc);
mexPrintf("filter_size: %d\n",filter_size);
mexPrintf(" n8flag: %d\n",n8flag);
mexPrintf(" normfl: %d\n",normfl);
mexPrintf(" blurfl: %d\n",blurfl);
mexPrintf(" verbosefl: %d\n",verbosefl);
}
/* Set edge list size */
if(n8flag)
nofedges=4*rows*cols-3*rows-3*cols+2;
else
nofedges=2*rows*cols-rows-cols;
if(nlhs>0) {
/* Allocate out elist */
out_dims[0]=4;
out_dims[1]=nofedges;
#ifdef INTEGER_EDGES
mx_elist = mxCreateNumericArray(2,out_dims,mxINT32_CLASS,mxREAL);
#else
mx_elist = mxCreateNumericArray(2,out_dims,mxDOUBLE_CLASS,mxREAL);
#endif
bf_elist = ebuffer_encapsulate(mx_elist);
/* Call computation function */
if(blurfl) {
/* Blur input image instead */
blur_buffer(bf_image,filter_size);
filter_size=1;
}
if(filter_size%2) {
if(n8flag) {
if(normfl)
d_max=image_to_edgelist_blur_n8_norm(bf_image,bf_elist,filter_size,verbosefl);
else
d_max=image_to_edgelist_blur_n8(bf_image,bf_elist,filter_size,verbosefl);
} else {
if(normfl)
d_max=image_to_edgelist_blur_norm(bf_image,bf_elist,filter_size,verbosefl);
else
d_max=image_to_edgelist_blur(bf_image,bf_elist,filter_size,verbosefl);
}
} else {
mexErrMsgTxt("bfz should be odd.\n");
/* d_max=image_to_edgelist_grad(bf_image,bf_elist,filter_size); */
}
if(tslist_flag) {
/* Call cdf sampling */
/* bf_ecdf=buffer_new(2,Ns,1); */
/* edgelist_to_cdf(bf_elist,bf_ecdf,d_max); */
/* Call thresholds interpolation */
bf_thres=ebuffer_new(1,timesteps,1);
if(verbosefl) mexPrintf("order=%d\n",ndim);
d_mean=evolution_thresholds2(bf_elist,bf_thres,ndim);
if(verbosefl) mexPrintf("d_mean=%g\n",d_mean);
/* Try linear dependence on mean edge strength */
/* min_margin=d_mean*min_margin_sc; */
}
/* Call computation function */
edgelist_to_bloblist(&bf_mvec,&bf_pvec,&bf_arate,bf_image,bf_elist,bf_thres,min_size,ainc,res,verbosefl);
center_moments(bf_mvec,bf_pvec);
validcnt=bloblist_mark_invalid(bf_mvec,min_size,bf_arate,(fpnum)min_margin);
validcnt=bloblist_shape_invalid(bf_mvec);
if(verbosefl) mexPrintf("validcnt=%d\n",validcnt);
if(tslist_flag) {
ebuffer_free(bf_thres);
/* buffer_free(bf_ecdf); */
}
/* Allocate out mvec */
out_dims[0]=6;
out_dims[1]=validcnt;
plhs[0] = mxCreateNumericArray(2,out_dims,mxDOUBLE_CLASS,mxREAL);
bf_mvec2 = buffer_encapsulate(plhs[0]);
/* Allocate out pvec */
out_dims[0]=3;
out_dims[1]=validcnt;
mx_pvec = mxCreateNumericArray(2,out_dims,mxDOUBLE_CLASS,mxREAL);
bf_pvec2 = buffer_encapsulate(mx_pvec);
/* Allocate out arates */
out_dims[0]=bf_arate->rows;
out_dims[1]=validcnt;
mx_arate = mxCreateNumericArray(2,out_dims,mxDOUBLE_CLASS,mxREAL);
bf_arate2 = buffer_encapsulate(mx_arate);
bloblist_compact(bf_mvec,bf_mvec2,bf_pvec,bf_pvec2,bf_arate,bf_arate2);
free(bf_mvec2); /* Only release struct */
free(bf_pvec2); /* Only release struct */
free(bf_arate2); /* Only release struct */
free(bf_elist); /* Only release struct */
buffer_free(bf_mvec); /* Release non-compacted mvec */
buffer_free(bf_pvec); /* Release non-compacted pvec */
buffer_free(bf_arate); /* Release non-compacted arate */
}
if(nlhs>1) plhs[1]=mx_pvec;
if(nlhs>2) plhs[2]=mx_arate;
if(nlhs>3) plhs[3]=mx_elist;
/* Free memory */
free(bf_image); /* Only release struct */
}
static int accesslog_parse_format(char * pformat, int len)
{
int i, j;
char ch;
format = pformat;
while(1) {
ch=get_next_char();
if(ch==0) break;
// It is string.
if(ch != '%') {
ff_ptr[ff_used].field = FORMAT_STRING;
ff_ptr[ff_used].string[0] = ch;
i=1;
while(1) {
ch=get_next_char();
if((ch=='%')||(ch==0)) break;
ff_ptr[ff_used].string[i]=ch;
i++;
}
ff_ptr[ff_used].string[i]=0;
ff_used++;
if(ch==0) break; // break the whole while(1) loop
}
ff_ptr[ff_used].string[0] = 0;
/* search for the terminating command */
ch=get_next_char();
if (ch == '{') {
i=0;
while(1) {
ch=get_next_char();
if (ch == 0) {
al_log_basic("\nERROR: failed to parse configuration file.\n");
exit(1);
}
else if (ch == '}') break;
ff_ptr[ff_used].string[i]=ch;
i++;
}
ff_ptr[ff_used].string[i]=0;
// Get next char after '}'
get_field_value(get_next_char());
if (ff_ptr[ff_used].field == FORMAT_COOKIE) {
/*
* we need to adjust the string as .c*k<cookiname>
* BUG: 64 bytes should be enough.
*/
char tmp[64];
strcpy(tmp, ff_ptr[ff_used].string);
snprintf(ff_ptr[ff_used].string, 64, ".c*k%s", tmp);
}
}
else {
get_field_value(ch);
//printf("%d : %d\n", ff_>used, ff_>ptr[ff_>used]->field);
}
ff_used++;
}
// Special case for URI/Query_string
// We want to do in this way.
for(j=0; j<ff_used; j++) {
switch (ff_ptr[j].field) {
case FORMAT_URL:
case FORMAT_QUERY_STRING:
case FORMAT_REQUEST_LINE:
strcpy(&ff_ptr[j].string[0], "uri");
break;
case FORMAT_HTTP_HOST:
strcpy(&ff_ptr[j].string[0], "host");
break;
case FORMAT_REMOTE_USER:
strcpy(&ff_ptr[j].string[0], "user"); // HTTP user field.
break;
default:
break;
}
}
return 0;
}
double frameFieldBackgroundMesh2D::get_smoothness(double u, double v)
{
return get_field_value(u,v,0.,smoothness);
}
