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