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