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