retrieval/d1_grs.c

   1 /*
   2  * Copyright (c) 1995-1998, Index Data.
   3  * See the file LICENSE for details.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: d1_grs.c,v $
   7  * Revision 1.15  1999-03-31 11:18:25  adam
   8  * Implemented odr_strdup. Added Reference ID to backend server API.
   9  *
  10  * Revision 1.14  1998/03/16 12:21:15  adam
  11  * Fixed problem with tag names that weren't set to the right value
  12  * when wildcards were used.
  13  *
  14  * Revision 1.13  1998/02/11 11:53:35  adam
  15  * Changed code so that it compiles as C++.
  16  *
  17  * Revision 1.12  1997/11/24 11:33:56  adam
  18  * Using function odr_nullval() instead of global ODR_NULLVAL when
  19  * appropriate.
  20  *
  21  * Revision 1.11  1997/11/18 09:51:09  adam
  22  * Removed element num_children from data1_node. Minor changes in
  23  * data1 to Explain.
  24  *
  25  * Revision 1.10  1997/09/17 12:10:36  adam
  26  * YAZ version 1.4.
  27  *
  28  * Revision 1.9  1997/05/14 06:54:03  adam
  29  * C++ support.
  30  *
  31  * Revision 1.8  1996/12/05 13:17:49  quinn
  32  * Fixed GRS-1 null-ref
  33  *
  34  * Revision 1.7  1996/10/11  11:57:23  quinn
  35  * Smallish
  36  *
  37  * Revision 1.6  1996/07/06  19:58:34  quinn
  38  * System headerfiles gathered in yconfig
  39  *
  40  * Revision 1.5  1996/06/03  09:46:42  quinn
  41  * Added OID data type.
  42  *
  43  * Revision 1.4  1996/05/01  12:45:30  quinn
  44  * Support use of local tag names in abs file.
  45  *
  46  * Revision 1.3  1995/11/13  09:27:35  quinn
  47  * Fiddling with the variant stuff.
  48  *
  49  * Revision 1.2  1995/11/01  13:54:46  quinn
  50  * Minor adjustments
  51  *
  52  * Revision 1.1  1995/11/01  11:56:07  quinn
  53  * Added Retrieval (data management) functions en masse.
  54  *
  55  *
  56  */
  57
  58 #include <assert.h>
  59 #include <stdlib.h>
  60
  61 #include <proto.h>
  62 #include <log.h>
  63
  64 #include <data1.h>
  65
  66 #define D1_VARIANTARRAY 20 /* fixed max length on sup'd variant-list. Lazy me */
  67
  68 static Z_ElementMetaData *get_ElementMetaData(ODR o)
  69 {
  70     Z_ElementMetaData *r = (Z_ElementMetaData *)odr_malloc(o, sizeof(*r));
  71
  72     r->seriesOrder = 0;
  73     r->usageRight = 0;
  74     r->num_hits = 0;
  75     r->hits = 0;
  76     r->displayName = 0;
  77     r->num_supportedVariants = 0;
  78     r->supportedVariants = 0;
  79     r->message = 0;
  80     r->elementDescriptor = 0;
  81     r->surrogateFor = 0;
  82     r->surrogateElement = 0;
  83     r->other = 0;
  84
  85     return r;
  86 }
  87
  88 /*
  89  * N should point to the *last* (leaf) triple in a sequence. Construct a variant
  90  * from each of the triples beginning (ending) with 'n', up to the
  91  * nearest parent tag. num should equal the number of triples in the
  92  * sequence.
  93  */
  94 static Z_Variant *make_variant(data1_node *n, int num, ODR o)
  95 {
  96     Z_Variant *v = (Z_Variant *)odr_malloc(o, sizeof(*v));
  97     data1_node *p;
  98
  99     v->globalVariantSetId = 0;
 100     v->num_triples = num;
 101     v->triples = (Z_Triple **)odr_malloc(o, sizeof(Z_Triple*) * num);
 102
 103     /*
 104      * cycle back up through the tree of variants
 105      * (traversing exactly 'level' variants).
 106      */
 107     for (p = n, num--; p && num >= 0; p = p->parent, num--)
 108     {
 109         Z_Triple *t;
 110
 111         assert(p->which == DATA1N_variant);
 112         t = v->triples[num] = (Z_Triple *)odr_malloc(o, sizeof(*t));
 113         t->variantSetId = 0;
 114         t->zclass = (int *)odr_malloc(o, sizeof(int));
 115         *t->zclass = p->u.variant.type->zclass->zclass;
 116         t->type = (int *)odr_malloc(o, sizeof(int));
 117         *t->type = p->u.variant.type->type;
 118
 119         switch (p->u.variant.type->datatype)
 120         {
 121             case DATA1K_string:
 122                 t->which = Z_Triple_internationalString;
 123                 t->value.internationalString =
 124                     odr_strdup(o, p->u.variant.value);
 125                 break;
 126             default:
 127                 logf(LOG_WARN, "Unable to handle value for variant %s",
 128                     p->u.variant.type->name);
 129                 return 0;
 130         }
 131     }
 132     return v;
 133 }
 134
 135 /*
 136  * Traverse the variant children of n, constructing a supportedVariant list.
 137  */
 138 static int traverse_triples(data1_node *n, int level, Z_ElementMetaData *m,
 139     ODR o)
 140 {
 141     data1_node *c;
 142
 143     for (c = n->child; c; c = c->next)
 144         if (c->which == DATA1N_data && level)
 145         {
 146             if (!m->supportedVariants)
 147                 m->supportedVariants = (Z_Variant **)odr_malloc(o, sizeof(Z_Variant*) *
 148                     D1_VARIANTARRAY);
 149             else if (m->num_supportedVariants >= D1_VARIANTARRAY)
 150             {
 151                 logf(LOG_WARN, "Too many variants (D1_VARIANTARRAY==%d)",
 152                     D1_VARIANTARRAY);
 153                 return -1;
 154             }
 155
 156             if (!(m->supportedVariants[m->num_supportedVariants++] =
 157                 make_variant(n, level, o)))
 158                 return -1;
 159         }
 160         else if (c->which == DATA1N_variant)
 161             if (traverse_triples(c, level+1, m, o) < 0)
 162                 return -1;
 163     return 0;
 164 }
 165
 166 static Z_ElementData *nodetoelementdata(data1_handle dh, data1_node *n,
 167                                         int select, int leaf,
 168                                         ODR o, int *len)
 169 {
 170     Z_ElementData *res = (Z_ElementData *)odr_malloc(o, sizeof(*res));
 171
 172     if (!n)
 173     {
 174         res->which = Z_ElementData_elementNotThere;
 175         res->u.elementNotThere = odr_nullval();
 176     }
 177     else if (n->which == DATA1N_data && (leaf || n->next == NULL))
 178     {
 179         char str[512];
 180         int toget;
 181         data1_node *p;
 182
 183         for (p = n->parent; p && p->which != DATA1N_tag; p = p->parent)
 184             ;
 185
 186         switch (n->u.data.what)
 187         {
 188             case DATA1I_num:
 189                 res->which = Z_ElementData_numeric;
 190                 res->u.numeric = (int *)odr_malloc(o, sizeof(int));
 191                 *res->u.numeric = atoi(n->u.data.data);
 192                 *len += 4;
 193                 break;
 194             case DATA1I_text:
 195                 toget = n->u.data.len;
 196                 if (p->u.tag.get_bytes > 0 && p->u.tag.get_bytes < toget)
 197                     toget = p->u.tag.get_bytes;
 198                 res->which = Z_ElementData_string;
 199                 res->u.string = (char *)odr_malloc(o, toget+1);
 200                 memcpy(res->u.string, n->u.data.data, toget);
 201                 res->u.string[toget] = '\0';
 202                 *len += toget;
 203                 break;
 204             case DATA1I_oid:
 205                 res->which = Z_ElementData_oid;
 206                 strncpy(str, n->u.data.data, n->u.data.len);
 207                 str[n->u.data.len] = '\0';
 208                 res->u.oid = odr_getoidbystr(o, str);
 209                 *len += n->u.data.len;
 210                 break;
 211             default:
 212                 logf(LOG_WARN, "Can't handle datatype.");
 213                 return 0;
 214         }
 215     }
 216     else
 217     {
 218         res->which = Z_ElementData_subtree;
 219         if (!(res->u.subtree = data1_nodetogr (dh, n->parent, select, o, len)))
 220             return 0;
 221     }
 222     return res;
 223 }
 224
 225 static Z_TaggedElement *nodetotaggedelement(data1_handle dh, data1_node *n,
 226                                             int select, ODR o,
 227                                             int *len)
 228 {
 229     Z_TaggedElement *res = (Z_TaggedElement *)odr_malloc(o, sizeof(*res));
 230     data1_tag *tag = 0;
 231     data1_node *data;
 232     int leaf;
 233
 234     if (n->which == DATA1N_tag)
 235     {
 236         if (n->u.tag.element)
 237             tag = n->u.tag.element->tag;
 238         data = n->child;
 239         leaf = 0;
 240     }
 241     /*
 242      * If we're a data element at this point, we need to insert a
 243      * wellKnown tag to wrap us up.
 244      */
 245     else if (n->which == DATA1N_data || n->which == DATA1N_variant)
 246     {
 247         if (!(tag = data1_gettagbyname (dh, n->root->u.root.absyn->tagset,
 248                                         "wellKnown")))
 249         {
 250             logf(LOG_WARN, "Unable to locate tag for 'wellKnown'");
 251             return 0;
 252         }
 253         data = n;
 254         leaf = 1;
 255     }
 256     else
 257     {
 258         logf(LOG_WARN, "Bad data.");
 259         return 0;
 260     }
 261
 262     res->tagType = (int *)odr_malloc(o, sizeof(int));
 263     *res->tagType = (tag && tag->tagset) ? tag->tagset->type : 3;
 264     res->tagValue = (Z_StringOrNumeric *)odr_malloc(o, sizeof(Z_StringOrNumeric));
 265     if (tag && tag->which == DATA1T_numeric)
 266     {
 267         res->tagValue->which = Z_StringOrNumeric_numeric;
 268         res->tagValue->u.numeric = (int *)odr_malloc(o, sizeof(int));
 269         *res->tagValue->u.numeric = tag->value.numeric;
 270     }
 271     else
 272     {
 273         char *tagstr;
 274
 275         if (n->which == DATA1N_tag)
 276             tagstr = n->u.tag.tag;       /* tag at node */
 277         else if (tag)
 278             tagstr = tag->value.string;  /* no take from well-known */
 279         else
 280             tagstr = "?";                /* no tag at all! */
 281         res->tagValue->which = Z_StringOrNumeric_string;
 282         res->tagValue->u.string = odr_strdup(o, tagstr);
 283     }
 284     res->tagOccurrence = 0;
 285     res->appliedVariant = 0;
 286     res->metaData = 0;
 287     if (n->which == DATA1N_variant || (data && data->which ==
 288         DATA1N_variant && data->next == NULL))
 289     {
 290         int nvars = 0;
 291
 292         res->metaData = get_ElementMetaData(o);
 293         if (n->which == DATA1N_tag && n->u.tag.make_variantlist)
 294             if (traverse_triples(data, 0, res->metaData, o) < 0)
 295                 return 0;
 296         while (data && data->which == DATA1N_variant)
 297         {
 298             nvars++;
 299             data = data->child;
 300         }
 301         if (n->which != DATA1N_tag || !n->u.tag.no_data_requested)
 302             res->appliedVariant = make_variant(data->parent, nvars-1, o);
 303     }
 304     if (n->which == DATA1N_tag && n->u.tag.no_data_requested)
 305     {
 306         res->content = (Z_ElementData *)odr_malloc(o, sizeof(*res->content));
 307         res->content->which = Z_ElementData_noDataRequested;
 308         res->content->u.noDataRequested = odr_nullval();
 309     }
 310     else if (!(res->content = nodetoelementdata (dh, data, select, leaf,
 311                                                  o, len)))
 312         return 0;
 313     *len += 10;
 314     return res;
 315 }
 316
 317 Z_GenericRecord *data1_nodetogr(data1_handle dh, data1_node *n,
 318                                 int select, ODR o, int *len)
 319 {
 320     Z_GenericRecord *res = (Z_GenericRecord *)odr_malloc(o, sizeof(*res));
 321     data1_node *c;
 322     int num_children = 0;
 323
 324     for (c = n->child; c; c = c->next)
 325         num_children++;
 326
 327     res->elements = (Z_TaggedElement **)odr_malloc(o, sizeof(Z_TaggedElement *) * num_children);
 328     res->num_elements = 0;
 329     for (c = n->child; c; c = c->next)
 330     {
 331         if (c->which == DATA1N_tag && select && !c->u.tag.node_selected)
 332             continue;
 333         if (!(res->elements[res->num_elements++] =
 334               nodetotaggedelement (dh, c, select, o, len)))
 335             return 0;
 336     }
 337     return res;
 338 }