gom/user_rec.c

   1 /* User record object in the gedcom object model.
   2    Copyright (C) 2002 The Genes Development Team
   3    This file is part of the Gedcom parser library.
   4    Contributed by Peter Verthez <Peter.Verthez@advalvas.be>, 2002.
   5
   6    The Gedcom parser library is free software; you can redistribute it
   7    and/or modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The Gedcom parser library is distributed in the hope that it will be
  12    useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the Gedcom parser library; if not, write to the
  18    Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19    02111-1307 USA.  */
  20
  21 /* $Id$ */
  22 /* $Name$ */
  23
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include "header.h"
  27 #include "submission.h"
  28 #include "submitter.h"
  29 #include "family.h"
  30 #include "individual.h"
  31 #include "multimedia.h"
  32 #include "note.h"
  33 #include "repository.h"
  34 #include "source.h"
  35 #include "address.h"
  36 #include "event.h"
  37 #include "place.h"
  38 #include "source_citation.h"
  39 #include "note_sub.h"
  40 #include "multimedia_link.h"
  41 #include "lds_event.h"
  42 #include "user_ref.h"
  43 #include "change_date.h"
  44 #include "personal_name.h"
  45 #include "family_link.h"
  46 #include "association.h"
  47 #include "source_event.h"
  48 #include "source_description.h"
  49 #include "user_rec.h"
  50 #include "gom.h"
  51 #include "gedcom.h"
  52 #include "gom_internal.h"
  53
  54 struct user_rec* gom_first_user_rec = NULL;
  55
  56 Gedcom_ctxt user_rec_start(_REC_PARAMS_)
  57 {
  58   struct user_rec* user = NULL;
  59   struct xref_value* xr = NULL;
  60   Gom_ctxt result  = NULL;
  61   Gedcom_ctxt ctxt = NULL;
  62   int err = 0;
  63
  64   if (GEDCOM_IS_XREF_PTR(xref))
  65     xr = GEDCOM_XREF_PTR(xref);
  66   if (xr) {
  67     if (! xr->object) {
  68       user = make_user_record(xr->string);
  69       xr->object = (Gedcom_ctxt) user;
  70     }
  71     ctxt = xr->object;
  72     if (ctxt) {
  73       user = (struct user_rec*) ctxt;
  74     }
  75   }
  76   else {
  77     user = make_user_record(NULL);
  78     ctxt = (Gedcom_ctxt) user;
  79   }
  80
  81   if (user) {
  82     user->tag = strdup(tag);
  83     if (! user->tag) {
  84       MEMORY_ERROR;
  85       err = 1;
  86     }
  87     else if (GEDCOM_IS_STRING(parsed_value)) {
  88       user->str_value = strdup(GEDCOM_STRING(parsed_value));
  89       if (!user->str_value) {
  90         MEMORY_ERROR;
  91         err = 1;
  92       }
  93     }
  94     else if (GEDCOM_IS_XREF_PTR(parsed_value))
  95       user->xref_value = GEDCOM_XREF_PTR(parsed_value);
  96
  97     if (! err)
  98       result = MAKE_GOM_CTXT(rec, user_rec, ctxt);
  99   }
 100
 101   return (Gedcom_ctxt)result;
 102 }
 103
 104 GET_REC_BY_XREF(user_rec, XREF_USER, gom_get_user_rec_by_xref)
 105
 106 Gedcom_ctxt user_elt_start(_ELT_PARAMS_)
 107 {
 108   Gom_ctxt ctxt = (Gom_ctxt)parent;
 109   Gom_ctxt result = NULL;
 110   int err = 0;
 111
 112   if (! ctxt)
 113     NO_CONTEXT;
 114   else {
 115     struct user_data *data
 116       = (struct user_data *)malloc(sizeof(struct user_data));
 117
 118     if (! data)
 119       MEMORY_ERROR;
 120     else {
 121       memset (data, 0, sizeof(struct user_data));
 122
 123       data->level = level;
 124       data->tag = strdup(tag);
 125       if (! data->tag) {
 126         MEMORY_ERROR;
 127         free(data);
 128         err = 1;
 129       }
 130       else if (GEDCOM_IS_STRING(parsed_value)) {
 131         data->str_value = strdup(GEDCOM_STRING(parsed_value));
 132         if (! data->str_value) {
 133           MEMORY_ERROR;
 134           free(data->tag);
 135           free(data->str_value);
 136           err = 1;
 137         }
 138       }
 139       else if (GEDCOM_IS_XREF_PTR(parsed_value))
 140         data->xref_value = GEDCOM_XREF_PTR(parsed_value);
 141
 142       if (! err) {
 143         switch (ctxt->obj_type) {
 144           case T_header:
 145             header_add_user_data(ctxt, data); break;
 146           case T_submission:
 147             submission_add_user_data(ctxt, data); break;
 148           case T_submitter:
 149             submitter_add_user_data(ctxt, data); break;
 150           case T_family:
 151             family_add_user_data(ctxt, data); break;
 152           case T_individual:
 153             individual_add_user_data(ctxt, data); break;
 154           case T_multimedia:
 155             multimedia_add_user_data(ctxt, data); break;
 156           case T_note:
 157             note_add_user_data(ctxt, data); break;
 158           case T_repository:
 159             repository_add_user_data(ctxt, data); break;
 160           case T_source:
 161             source_add_user_data(ctxt, data); break;
 162           case T_user_rec:
 163             user_rec_add_user_data(ctxt, data); break;
 164           case T_address:
 165             address_add_user_data(ctxt, data); break;
 166           case T_event:
 167             event_add_user_data(ctxt, data); break;
 168           case T_place:
 169             place_add_user_data(ctxt, data); break;
 170           case T_source_citation:
 171             citation_add_user_data(ctxt, data); break;
 172           case T_note_sub:
 173             note_sub_add_user_data(ctxt, data); break;
 174           case T_multimedia_link:
 175             multimedia_link_add_user_data(ctxt, data); break;
 176           case T_lds_event:
 177             lds_event_add_user_data(ctxt, data); break;
 178           case T_user_ref_number:
 179             user_ref_add_user_data(ctxt, data); break;
 180           case T_change_date:
 181             change_date_add_user_data(ctxt, data); break;
 182           case T_personal_name:
 183             name_add_user_data(ctxt, data); break;
 184           case T_family_link:
 185             family_link_add_user_data(ctxt, data); break;
 186           case T_association:
 187             association_add_user_data(ctxt, data); break;
 188           case T_source_event:
 189             source_event_add_user_data(ctxt, data); break;
 190           case T_source_description:
 191             source_description_add_user_data(ctxt, data); break;
 192           default:
 193             UNEXPECTED_CONTEXT(ctxt->ctxt_type);
 194         }
 195         result = make_gom_ctxt(elt, ctxt->obj_type, ctxt->ctxt_ptr);
 196       }
 197     }
 198   }
 199
 200   return (Gedcom_ctxt)result;
 201 }
 202
 203 void user_rec_subscribe()
 204 {
 205   gedcom_subscribe_to_record(REC_USER, user_rec_start, def_rec_end);
 206   gedcom_subscribe_to_element(ELT_USER, user_elt_start, def_elt_end);
 207 }
 208
 209 void user_rec_add_user_data(Gom_ctxt ctxt, struct user_data* data)
 210 {
 211   struct user_rec *obj = SAFE_CTXT_CAST(user_rec, ctxt);
 212   if (obj)
 213     LINK_CHAIN_ELT(user_data, obj->extra, data);
 214 }
 215
 216 void user_data_cleanup(struct user_data* data)
 217 {
 218   if (data) {
 219     SAFE_FREE(data->tag);
 220     SAFE_FREE(data->str_value);
 221   }
 222 }
 223
 224 void user_rec_cleanup(struct user_rec* rec)
 225 {
 226   if (rec) {
 227     SAFE_FREE(rec->xrefstr);
 228     SAFE_FREE(rec->tag);
 229     SAFE_FREE(rec->str_value);
 230     DESTROY_CHAIN_ELTS(user_data, rec->extra, user_data_cleanup);
 231   }
 232 }
 233
 234 void user_recs_cleanup()
 235 {
 236   DESTROY_CHAIN_ELTS(user_rec, gom_first_user_rec, user_rec_cleanup);
 237 }
 238
 239 struct user_rec* gom_get_first_user_rec()
 240 {
 241   return gom_first_user_rec;
 242 }
 243
 244 struct user_rec* make_user_record(const char* xrefstr)
 245 {
 246   struct user_rec* rec = NULL;
 247   MAKE_CHAIN_ELT(user_rec, gom_first_user_rec, rec);
 248   if (rec && xrefstr) {
 249     rec->xrefstr = strdup(xrefstr);
 250     if (! rec->xrefstr) MEMORY_ERROR;
 251   }
 252   return rec;
 253 }