-/* $Id: zsets.c,v 1.124 2007-10-31 16:56:14 adam Exp $
+/* $Id: zsets.c,v 1.125 2007-11-01 15:59:47 adam Exp $
Copyright (C) 1995-2007
Index Data ApS
rset->hits_limit = sset->approx_limit;
if (!i)
{
- res = resultSetRank (zh, sset, rset, rset_nmem);
+ res = resultSetRank(zh, sset, rset, rset_nmem);
}
else
{
- res = resultSetSortSingle (zh, nmem, sset, rset,
+ res = resultSetSortSingle(zh, nmem, sset, rset,
sort_sequence, &sort_status);
}
sset->rset = rset;
zebraSet->num_bases = num_bases;
zebraSet->basenames =
- nmem_malloc (zebraSet->nmem, num_bases * sizeof(*zebraSet->basenames));
+ nmem_malloc(zebraSet->nmem, num_bases * sizeof(*zebraSet->basenames));
for (i = 0; i<num_bases; i++)
zebraSet->basenames[i] = nmem_strdup(zebraSet->nmem, basenames[i]);
{
assert(zh); /* compiler shut up */
if (!s->nmem)
- s->nmem = nmem_create ();
+ s->nmem = nmem_create();
if (!s->term_entries)
{
int i;
s->term_entries_max = 1000;
s->term_entries =
- nmem_malloc (s->nmem, s->term_entries_max *
+ nmem_malloc(s->nmem, s->term_entries_max *
sizeof(*s->term_entries));
for (i = 0; i < s->term_entries_max; i++)
s->term_entries[i].term = 0;
if (s->hits < s->term_entries_max)
{
s->term_entries[s->hits].reg_type = reg_type;
- s->term_entries[s->hits].db = nmem_strdup (s->nmem, db);
+ s->term_entries[s->hits].db = nmem_strdup(s->nmem, db);
s->term_entries[s->hits].index_name = nmem_strdup(s->nmem, index_name);
s->term_entries[s->hits].term = nmem_strdup(s->nmem, term);
}
int i;
for (s = zh->sets; s; s = s->next)
- if (!strcmp (s->name, name))
+ if (!strcmp(s->name, name))
break;
if (!log_level_set)
{
if (s->cache_rfd)
rset_close(s->cache_rfd);
- rset_delete (s->rset);
+ rset_delete(s->rset);
}
if (s->rset_nmem)
- nmem_destroy (s->rset_nmem);
+ nmem_destroy(s->rset_nmem);
if (s->nmem)
- nmem_destroy (s->nmem);
+ nmem_destroy(s->nmem);
}
else
{
const char *sort_max_str = zebra_get_resource(zh, "sortmax", "1000");
yaz_log(log_level_resultsets, "adding result set %s", name);
- s = (ZebraSet) xmalloc (sizeof(*s));
+ s = (ZebraSet) xmalloc(sizeof(*s));
s->next = zh->sets;
zh->sets = s;
- s->name = (char *) xmalloc (strlen(name)+1);
- strcpy (s->name, name);
+ s->name = xstrdup(name);
s->sort_info = (struct zset_sort_info *)
- xmalloc (sizeof(*s->sort_info));
+ xmalloc(sizeof(*s->sort_info));
s->sort_info->max_entries = atoi(sort_max_str);
if (s->sort_info->max_entries < 2)
s->sort_info->max_entries = 2;
s->sort_info->entries = (struct zset_sort_entry **)
- xmalloc (sizeof(*s->sort_info->entries) *
+ xmalloc(sizeof(*s->sort_info->entries) *
s->sort_info->max_entries);
s->sort_info->all_entries = (struct zset_sort_entry *)
- xmalloc (sizeof(*s->sort_info->all_entries) *
+ xmalloc(sizeof(*s->sort_info->all_entries) *
s->sort_info->max_entries);
for (i = 0; i < s->sort_info->max_entries; i++)
s->sort_info->entries[i] = s->sort_info->all_entries + i;
ZebraSet s;
for (s = zh->sets; s; s = s->next)
- if (!strcmp (s->name, name))
+ if (!strcmp(s->name, name))
{
if (!s->term_entries && !s->rset && s->rpn)
{
- NMEM nmem = nmem_create ();
+ NMEM nmem = nmem_create();
yaz_log(log_level_resultsets, "research %s", name);
if (!s->rset_nmem)
- s->rset_nmem=nmem_create();
+ s->rset_nmem = nmem_create();
resultSetSearch(zh, nmem, s->rset_nmem, s->rpn, s);
if (s->rset && s->sortSpec)
{
int sort_status;
yaz_log(log_level_resultsets, "resort %s", name);
- resultSetSortSingle (zh, nmem, s, s->rset, s->sortSpec,
+ resultSetSortSingle(zh, nmem, s, s->rset, s->sortSpec,
&sort_status);
}
- nmem_destroy (nmem);
+ nmem_destroy(nmem);
}
return s;
}
return NULL;
}
-void resultSetInvalidate (ZebraHandle zh)
+void resultSetInvalidate(ZebraHandle zh)
{
ZebraSet s = zh->sets;
{
if (s->cache_rfd)
rset_close(s->cache_rfd);
- rset_delete (s->rset);
+ rset_delete(s->rset);
}
s->rset = 0;
s->cache_rfd = 0;
if (num >= 0)
{
for (i = 0; i<num; i++)
- if (!strcmp (s->name, names[i]))
+ if (!strcmp(s->name, names[i]))
{
if (statuses)
statuses[i] = Z_DeleteStatus_success;
{
*ss = s->next;
- xfree (s->sort_info->all_entries);
- xfree (s->sort_info->entries);
- xfree (s->sort_info);
+ xfree(s->sort_info->all_entries);
+ xfree(s->sort_info->entries);
+ xfree(s->sort_info);
if (s->nmem)
- nmem_destroy (s->nmem);
+ nmem_destroy(s->nmem);
if (s->rset)
{
if (s->cache_rfd)
rset_close(s->cache_rfd);
- rset_delete (s->rset);
+ rset_delete(s->rset);
}
if (s->rset_nmem)
nmem_destroy(s->rset_nmem);
- xfree (s->name);
- xfree (s);
+ xfree(s->name);
+ xfree(s);
}
else
ss = &s->next;
if (!log_level_set)
loglevels();
- if (!(sset = resultSetGet (zh, name)))
+ if (!(sset = resultSetGet(zh, name)))
return NULL;
if (!(rset = sset->rset))
{
if (!sset->term_entries)
return 0;
- sr = (ZebraMetaRecord *) xmalloc (sizeof(*sr) * num);
+ sr = (ZebraMetaRecord *) xmalloc(sizeof(*sr) * num);
for (i = 0; i<num; i++)
{
sr[i].sysno = 0;
}
else
{
- sr = (ZebraMetaRecord *) xmalloc (sizeof(*sr) * num);
+ sr = (ZebraMetaRecord *) xmalloc(sizeof(*sr) * num);
for (i = 0; i<num; i++)
{
sr[i].sysno = 0;
{
if (sset->cache_rfd)
rset_close(sset->cache_rfd);
- rfd = rset_open (rset, RSETF_READ);
+ rfd = rset_open(rset, RSETF_READ);
}
- while (num_i < num && rset_read (rfd, &key, 0))
+ while (num_i < num && rset_read(rfd, &key, 0))
{
zint this_sys = key.mem[sysno_mem_index];
if (this_sys != psysno)
continue;
}
position++;
- assert (num_i < num);
+ assert(num_i < num);
if (position == positions[num_i])
{
sr[num_i].sysno = psysno;
return sr;
}
-void zebra_meta_records_destroy (ZebraHandle zh, ZebraMetaRecord *records,
+void zebra_meta_records_destroy(ZebraHandle zh, ZebraMetaRecord *records,
int num)
{
assert(zh); /* compiler shut up about unused arg */
- xfree (records);
+ xfree(records);
}
struct sortKeyInfo {
--j;
}
sort_info->entries[i] = new_entry;
- assert (new_entry);
+ assert(new_entry);
for (i = 0; i<num_criteria; i++)
{
char *new_entry_buf = cmp_buf[i] + j * SORT_IDX_ENTRYSIZE;
--j;
}
sort_info->entries[i] = new_entry;
- assert (new_entry);
+ assert(new_entry);
new_entry->sysno = sysno;
new_entry->score = score;
}
nset->num_bases = rset->num_bases;
nset->basenames =
- nmem_malloc (nset->nmem, nset->num_bases * sizeof(*rset->basenames));
+ nmem_malloc(nset->nmem, nset->num_bases * sizeof(*rset->basenames));
for (i = 0; i<rset->num_bases; i++)
nset->basenames[i] = nmem_strdup(nset->nmem, rset->basenames[i]);
loglevels();
yaz_log(log_level_sort, "result set sort input=%s output=%s",
*input_setnames, output_setname);
- sset = resultSetGet (zh, input_setnames[0]);
+ sset = resultSetGet(zh, input_setnames[0]);
if (!sset)
{
zebra_setError(zh, YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
input_setnames[0]);
return ZEBRA_FAIL;
}
- if (strcmp (output_setname, input_setnames[0]))
+ if (strcmp(output_setname, input_setnames[0]))
sset = resultSetClone(zh, output_setname, sset);
sset->sortSpec = copy_SortKeySpecList(sort_sequence, sset->nmem);
return resultSetSortSingle (zh, nmem, sset, rset, sort_sequence,
* SORT_IDX_ENTRYSIZE);
tmp_cmp_buf[i] = xmalloc(SORT_IDX_ENTRYSIZE);
}
- rfd = rset_open (rset, RSETF_READ);
- while (rset_read (rfd, &key, &termid))
+ rfd = rset_open(rset, RSETF_READ);
+ while (rset_read(rfd, &key, &termid))
{
zint this_sys = key.mem[sysno_mem_index];
if (log_level_searchhits)
tmp_cmp_buf);
}
}
- rset_close (rfd);
+ rset_close(rfd);
for (i = 0; i<num_criteria; i++)
{
{
ZebraSet s;
- if ((s = resultSetGet (zh, resultSetId)))
+ if ((s = resultSetGet(zh, resultSetId)))
return s->rset;
return NULL;
}
stop_flag = 1;
if (psysno)
{ /* only if we did have a previous record */
- score = (*rc->calc) (handle, psysno, pstaticrank,
+ score = (*rc->calc)(handle, psysno, pstaticrank,
&stop_flag);
/* insert the hit. A=Ascending */
- resultSetInsertRank (zh, sort_info, psysno, score, 'A');
+ resultSetInsertRank(zh, sort_info, psysno, score, 'A');
count++;
}
if (stop_flag)
if (zh->m_staticrank)
pstaticrank = key.mem[0];
}
- (*rc->add) (handle, CAST_ZINT_TO_INT(seqno), termid);
+ (*rc->add)(handle, CAST_ZINT_TO_INT(seqno), termid);
}
/* no more items */
if (psysno)
resultSetInsertRank(zh, sort_info, psysno, score, 'A');
count++;
}
- (*rc->end) (zh->reg, handle);
- rset_close (rfd);
+ (*rc->end)(zh->reg, handle);
+ rset_close(rfd);
}
zebraSet->hits = rset->hits_count;
ZebraRankClass zebraRankLookup(ZebraHandle zh, const char *name)
{
ZebraRankClass p = zh->reg->rank_classes;
- while (p && strcmp (p->control->name, name))
+ while (p && strcmp(p->control->name, name))
p = p->next;
if (p && !p->init_flag)
{
void zebraRankInstall(struct zebra_register *reg, struct rank_control *ctrl)
{
- ZebraRankClass p = (ZebraRankClass) xmalloc (sizeof(*p));
- p->control = (struct rank_control *) xmalloc (sizeof(*p->control));
- memcpy (p->control, ctrl, sizeof(*p->control));
- p->control->name = xstrdup (ctrl->name);
+ ZebraRankClass p = (ZebraRankClass) xmalloc(sizeof(*p));
+ p->control = (struct rank_control *) xmalloc(sizeof(*p->control));
+ memcpy(p->control, ctrl, sizeof(*p->control));
+ p->control->name = xstrdup(ctrl->name);
p->init_flag = 0;
p->next = reg->rank_classes;
reg->rank_classes = p;
struct it_key key;
RSET rsets[2], rset_comb;
RSET rset_temp = rset_create_temp(nmem, kc, kc->scope,
- res_get (zh->res, "setTmpDir"),0 );
+ res_get(zh->res, "setTmpDir"),0 );
TERMID termid;
RSFD rsfd = rset_open(rset_temp, RSETF_WRITE);
key.mem[2] = 0;
key.mem[3] = 0;
key.len = 2;
- rset_write (rsfd, &key);
- rset_close (rsfd);
+ rset_write(rsfd, &key);
+ rset_close(rsfd);
rsets[0] = rset_temp;
rsets[1] = rset_dup(sset->rset);