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