gts/named.c

   1 /* GTS - Library for the manipulation of triangulated surfaces
   2  * Copyright (C) 1999 Stéphane Popinet
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include <string.h>
  21 #include "gts.h"
  22
  23 static void nvertex_read (GtsObject ** po, GtsFile * fp)
  24 {
  25   if ((*po)->klass->parent_class->read)
  26     (* (*po)->klass->parent_class->read) (po, fp);
  27
  28   if (fp->type != '\n' && fp->type != GTS_ERROR) {
  29     strncpy (GTS_NVERTEX (*po)->name, fp->token->str, GTS_NAME_LENGTH);
  30     gts_file_next_token (fp);
  31   }
  32 }
  33
  34 static void nvertex_write (GtsObject * o, FILE * fptr)
  35 {
  36   GtsNVertex * nv = GTS_NVERTEX (o);
  37
  38   (* o->klass->parent_class->write) (o, fptr);
  39   if (nv->name[0] != '\0')
  40     fprintf (fptr, " %s", nv->name);
  41 }
  42
  43 static void nvertex_class_init (GtsNVertexClass * klass)
  44 {
  45   GTS_OBJECT_CLASS (klass)->read = nvertex_read;
  46   GTS_OBJECT_CLASS (klass)->write = nvertex_write;
  47 }
  48
  49 static void nvertex_init (GtsNVertex * nvertex)
  50 {
  51   nvertex->name[0] = '\0';
  52 }
  53
  54 /**
  55  * gts_nvertex_class:
  56  *
  57  * Returns: the #GtsNVertexClass.
  58  */
  59 GtsNVertexClass * gts_nvertex_class (void)
  60 {
  61   static GtsNVertexClass * klass = NULL;
  62
  63   if (klass == NULL) {
  64     GtsObjectClassInfo nvertex_info = {
  65       "GtsNVertex",
  66       sizeof (GtsNVertex),
  67       sizeof (GtsNVertexClass),
  68       (GtsObjectClassInitFunc) nvertex_class_init,
  69       (GtsObjectInitFunc) nvertex_init,
  70       (GtsArgSetFunc) NULL,
  71       (GtsArgGetFunc) NULL
  72     };
  73     klass = gts_object_class_new (GTS_OBJECT_CLASS (gts_vertex_class ()),
  74                                   &nvertex_info);
  75   }
  76
  77   return klass;
  78 }
  79
  80 static void nedge_read (GtsObject ** po, GtsFile * fp)
  81 {
  82   if (fp->type != GTS_STRING) {
  83     gts_file_error (fp, "expecting a string (name)");
  84     return;
  85   }
  86   strncpy (GTS_NEDGE (*po)->name, fp->token->str, GTS_NAME_LENGTH);
  87   gts_file_next_token (fp);
  88 }
  89
  90 static void nedge_write (GtsObject * o, FILE * fptr)
  91 {
  92   GtsNEdge * ne = GTS_NEDGE (o);
  93
  94   if (ne->name[0] != '\0')
  95     fprintf (fptr, " %s", ne->name);
  96 }
  97
  98 static void nedge_class_init (GtsNEdgeClass * klass)
  99 {
 100   GTS_OBJECT_CLASS (klass)->read = nedge_read;
 101   GTS_OBJECT_CLASS (klass)->write = nedge_write;
 102 }
 103
 104 static void nedge_init (GtsNEdge * nedge)
 105 {
 106   nedge->name[0] = '\0';
 107 }
 108
 109 /**
 110  * gts_nedge_class:
 111  *
 112  * Returns: the #GtsNEdgeClass.
 113  */
 114 GtsNEdgeClass * gts_nedge_class (void)
 115 {
 116   static GtsNEdgeClass * klass = NULL;
 117
 118   if (klass == NULL) {
 119     GtsObjectClassInfo nedge_info = {
 120       "GtsNEdge",
 121       sizeof (GtsNEdge),
 122       sizeof (GtsNEdgeClass),
 123       (GtsObjectClassInitFunc) nedge_class_init,
 124       (GtsObjectInitFunc) nedge_init,
 125       (GtsArgSetFunc) NULL,
 126       (GtsArgGetFunc) NULL
 127     };
 128     klass = gts_object_class_new (GTS_OBJECT_CLASS (gts_edge_class ()),
 129                                   &nedge_info);
 130   }
 131
 132   return klass;
 133 }
 134
 135 static void nface_read (GtsObject ** po, GtsFile * fp)
 136 {
 137   if (fp->type != GTS_STRING) {
 138     gts_file_error (fp, "expecting a string (name)");
 139     return;
 140   }
 141   strncpy (GTS_NFACE (*po)->name, fp->token->str, GTS_NAME_LENGTH);
 142   gts_file_next_token (fp);
 143 }
 144
 145 static void nface_write (GtsObject * o, FILE * fptr)
 146 {
 147   GtsNFace * nf = GTS_NFACE (o);
 148
 149   if (nf->name[0] != '\0')
 150     fprintf (fptr, " %s", GTS_NFACE (o)->name);
 151 }
 152
 153 static void nface_class_init (GtsNFaceClass * klass)
 154 {
 155   GTS_OBJECT_CLASS (klass)->read = nface_read;
 156   GTS_OBJECT_CLASS (klass)->write = nface_write;
 157 }
 158
 159 static void nface_init (GtsNFace * nface)
 160 {
 161   nface->name[0] = '\0';
 162 }
 163
 164 /**
 165  * gts_nface_class:
 166  *
 167  * Returns: the #GtsNFaceClass.
 168  */
 169 GtsNFaceClass * gts_nface_class (void)
 170 {
 171   static GtsNFaceClass * klass = NULL;
 172
 173   if (klass == NULL) {
 174     GtsObjectClassInfo nface_info = {
 175       "GtsNFace",
 176       sizeof (GtsNFace),
 177       sizeof (GtsNFaceClass),
 178       (GtsObjectClassInitFunc) nface_class_init,
 179       (GtsObjectInitFunc) nface_init,
 180       (GtsArgSetFunc) NULL,
 181       (GtsArgGetFunc) NULL
 182     };
 183     klass = gts_object_class_new (GTS_OBJECT_CLASS (gts_face_class ()),
 184                                   &nface_info);
 185   }
 186
 187   return klass;
 188 }