retrieval/d1_grs.c

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