src/gromacs/fileio/gmxfio_rw.c

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 1991-2000, University of Groningen, The Netherlands.
   5  * Copyright (c) 2001-2004, The GROMACS development team.
   6  * Copyright (c) 2013,2014,2015, by the GROMACS development team, led by
   7  * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
   8  * and including many others, as listed in the AUTHORS file in the
   9  * top-level source directory and at http://www.gromacs.org.
  10  *
  11  * GROMACS is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public License
  13  * as published by the Free Software Foundation; either version 2.1
  14  * of the License, or (at your option) any later version.
  15  *
  16  * GROMACS is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with GROMACS; if not, see
  23  * http://www.gnu.org/licenses, or write to the Free Software Foundation,
  24  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  25  *
  26  * If you want to redistribute modifications to GROMACS, please
  27  * consider that scientific software is very special. Version
  28  * control is crucial - bugs must be traceable. We will be happy to
  29  * consider code for inclusion in the official distribution, but
  30  * derived work must not be called official GROMACS. Details are found
  31  * in the README & COPYING files - if they are missing, get the
  32  * official version at http://www.gromacs.org.
  33  *
  34  * To help us fund GROMACS development, we humbly ask that you cite
  35  * the research papers on the package. Check out http://www.gromacs.org.
  36  */
  37 #include "gmxpre.h"
  38
  39 #include "gromacs/fileio/gmxfio.h"
  40
  41 #include "gmxfio-impl.h"
  42
  43 /*******************************************************************
  44  *
  45  * READ/WRITE FUNCTIONS
  46  *
  47  *******************************************************************/
  48
  49 gmx_bool gmx_fio_writee_string(t_fileio *fio, const char *item,
  50                                const char *desc, const char *srcfile, int line)
  51 {
  52     gmx_bool ret;
  53     gmx_fio_lock(fio);
  54     ret = fio->iotp->nwrite(fio, item, 1, eioSTRING, desc, srcfile, line);
  55     gmx_fio_unlock(fio);
  56     return ret;
  57 }
  58
  59 gmx_bool gmx_fio_doe_real(t_fileio *fio, real *item,
  60                           const char *desc, const char *srcfile, int line)
  61 {
  62     gmx_bool ret;
  63     gmx_fio_lock(fio);
  64     if (fio->bRead)
  65     {
  66         ret = fio->iotp->nread(fio, item, 1, eioREAL, desc, srcfile, line);
  67     }
  68     else
  69     {
  70         ret = fio->iotp->nwrite(fio, item, 1, eioREAL, desc, srcfile, line);
  71     }
  72     gmx_fio_unlock(fio);
  73     return ret;
  74
  75 }
  76
  77 gmx_bool gmx_fio_doe_float(t_fileio *fio, float *item,
  78                            const char *desc, const char *srcfile, int line)
  79 {
  80     gmx_bool ret;
  81     gmx_fio_lock(fio);
  82     if (fio->bRead)
  83     {
  84         ret = fio->iotp->nread(fio, item, 1, eioFLOAT, desc, srcfile, line);
  85     }
  86     else
  87     {
  88         ret = fio->iotp->nwrite(fio, item, 1, eioFLOAT, desc, srcfile, line);
  89     }
  90     gmx_fio_unlock(fio);
  91     return ret;
  92 }
  93
  94 gmx_bool gmx_fio_doe_double(t_fileio *fio, double *item,
  95                             const char *desc, const char *srcfile, int line)
  96 {
  97     gmx_bool ret;
  98     gmx_fio_lock(fio);
  99     if (fio->bRead)
 100     {
 101         ret = fio->iotp->nread(fio, item, 1, eioDOUBLE, desc, srcfile, line);
 102     }
 103     else
 104     {
 105         ret = fio->iotp->nwrite(fio, item, 1, eioDOUBLE, desc, srcfile, line);
 106     }
 107     gmx_fio_unlock(fio);
 108     return ret;
 109 }
 110
 111
 112 gmx_bool gmx_fio_doe_gmx_bool(t_fileio *fio, gmx_bool *item,
 113                               const char *desc, const char *srcfile, int line)
 114 {
 115     gmx_bool ret;
 116     int      itmp;
 117
 118     gmx_fio_lock(fio);
 119     if (fio->bRead)
 120     {
 121         ret   = fio->iotp->nread(fio, &itmp, 1, eioINT, desc, srcfile, line);
 122         *item = itmp;
 123     }
 124     else
 125     {
 126         itmp = *item;
 127         ret  = fio->iotp->nwrite(fio, &itmp, 1, eioINT, desc, srcfile, line);
 128     }
 129     gmx_fio_unlock(fio);
 130     return ret;
 131 }
 132
 133 gmx_bool gmx_fio_doe_int(t_fileio *fio, int *item,
 134                          const char *desc, const char *srcfile, int line)
 135 {
 136     gmx_bool ret;
 137     gmx_fio_lock(fio);
 138     if (fio->bRead)
 139     {
 140         ret = fio->iotp->nread(fio, item, 1, eioINT, desc, srcfile, line);
 141     }
 142     else
 143     {
 144         ret = fio->iotp->nwrite(fio, item, 1, eioINT, desc, srcfile, line);
 145     }
 146     gmx_fio_unlock(fio);
 147     return ret;
 148 }
 149
 150 gmx_bool gmx_fio_doe_int64(t_fileio *fio, gmx_int64_t *item,
 151                            const char *desc, const char *srcfile, int line)
 152 {
 153     gmx_bool ret;
 154     gmx_fio_lock(fio);
 155     if (fio->bRead)
 156     {
 157         ret = fio->iotp->nread(fio, item, 1, eioINT64, desc, srcfile, line);
 158     }
 159     else
 160     {
 161         ret = fio->iotp->nwrite(fio, item, 1, eioINT64, desc, srcfile, line);
 162     }
 163     gmx_fio_unlock(fio);
 164     return ret;
 165 }
 166
 167 gmx_bool gmx_fio_doe_uchar(t_fileio *fio, unsigned char *item,
 168                            const char *desc, const char *srcfile, int line)
 169 {
 170     gmx_bool ret;
 171     gmx_fio_lock(fio);
 172     if (fio->bRead)
 173     {
 174         ret = fio->iotp->nread(fio, item, 1, eioUCHAR, desc, srcfile, line);
 175     }
 176     else
 177     {
 178         ret = fio->iotp->nwrite(fio, item, 1, eioUCHAR, desc, srcfile, line);
 179     }
 180     gmx_fio_unlock(fio);
 181     return ret;
 182 }
 183
 184 gmx_bool gmx_fio_doe_ushort(t_fileio *fio, unsigned short *item,
 185                             const char *desc, const char *srcfile, int line)
 186 {
 187     gmx_bool ret;
 188     gmx_fio_lock(fio);
 189     if (fio->bRead)
 190     {
 191         ret = fio->iotp->nread(fio, item, 1, eioUSHORT, desc, srcfile, line);
 192     }
 193     else
 194     {
 195         ret = fio->iotp->nwrite(fio, item, 1, eioUSHORT, desc, srcfile, line);
 196     }
 197     gmx_fio_unlock(fio);
 198     return ret;
 199 }
 200
 201 gmx_bool gmx_fio_doe_rvec(t_fileio *fio, rvec *item,
 202                           const char *desc, const char *srcfile, int line)
 203 {
 204     gmx_bool ret;
 205     gmx_fio_lock(fio);
 206     if (fio->bRead)
 207     {
 208         ret = fio->iotp->nread(fio, item, 1, eioRVEC, desc, srcfile, line);
 209     }
 210     else
 211     {
 212         ret = fio->iotp->nwrite(fio, item, 1, eioRVEC, desc, srcfile, line);
 213     }
 214     gmx_fio_unlock(fio);
 215     return ret;
 216 }
 217
 218 gmx_bool gmx_fio_doe_ivec(t_fileio *fio, ivec *item,
 219                           const char *desc, const char *srcfile, int line)
 220 {
 221     gmx_bool ret;
 222     gmx_fio_lock(fio);
 223     if (fio->bRead)
 224     {
 225         ret = fio->iotp->nread(fio, item, 1, eioIVEC, desc, srcfile, line);
 226     }
 227     else
 228     {
 229         ret = fio->iotp->nwrite(fio, item, 1, eioIVEC, desc, srcfile, line);
 230     }
 231     gmx_fio_unlock(fio);
 232     return ret;
 233 }
 234
 235 gmx_bool gmx_fio_doe_string(t_fileio *fio, char *item,
 236                             const char *desc, const char *srcfile, int line)
 237 {
 238     gmx_bool ret;
 239     gmx_fio_lock(fio);
 240     if (fio->bRead)
 241     {
 242         ret = fio->iotp->nread(fio, item, 1, eioSTRING, desc, srcfile, line);
 243     }
 244     else
 245     {
 246         ret = fio->iotp->nwrite(fio, item, 1, eioSTRING, desc, srcfile, line);
 247     }
 248     gmx_fio_unlock(fio);
 249     return ret;
 250 }
 251
 252
 253 /* Array reading & writing */
 254
 255 gmx_bool gmx_fio_ndoe_real(t_fileio *fio, real *item, int n,
 256                            const char *desc, const char *srcfile, int line)
 257 {
 258     gmx_bool ret = TRUE;
 259     int      i;
 260     gmx_fio_lock(fio);
 261     for (i = 0; i < n; i++)
 262     {
 263         if (fio->bRead)
 264         {
 265             ret = ret && fio->iotp->nread(fio, &(item[i]), 1, eioREAL, desc,
 266                                           srcfile, line);
 267         }
 268         else
 269         {
 270             ret = ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioREAL, desc,
 271                                            srcfile, line);
 272         }
 273     }
 274     gmx_fio_unlock(fio);
 275     return ret;
 276 }
 277
 278
 279
 280 gmx_bool gmx_fio_ndoe_float(t_fileio *fio, float *item, int n,
 281                             const char *desc, const char *srcfile, int line)
 282 {
 283     gmx_bool ret = TRUE;
 284     int      i;
 285     gmx_fio_lock(fio);
 286     for (i = 0; i < n; i++)
 287     {
 288         if (fio->bRead)
 289         {
 290             ret = ret && fio->iotp->nread(fio, &(item[i]), 1, eioFLOAT, desc,
 291                                           srcfile, line);
 292         }
 293         else
 294         {
 295             ret = ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioFLOAT, desc,
 296                                            srcfile, line);
 297         }
 298     }
 299     gmx_fio_unlock(fio);
 300     return ret;
 301 }
 302
 303
 304
 305 gmx_bool gmx_fio_ndoe_double(t_fileio *fio, double *item, int n,
 306                              const char *desc, const char *srcfile, int line)
 307 {
 308     gmx_bool ret = TRUE;
 309     int      i;
 310     gmx_fio_lock(fio);
 311     for (i = 0; i < n; i++)
 312     {
 313         if (fio->bRead)
 314         {
 315             ret = ret && fio->iotp->nread(fio, &(item[i]), 1, eioDOUBLE, desc,
 316                                           srcfile, line);
 317         }
 318         else
 319         {
 320             ret = ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioDOUBLE, desc,
 321                                            srcfile, line);
 322         }
 323     }
 324     gmx_fio_unlock(fio);
 325     return ret;
 326 }
 327
 328
 329
 330 gmx_bool gmx_fio_ndoe_gmx_bool(t_fileio *fio, gmx_bool *item, int n,
 331                                const char *desc, const char *srcfile, int line)
 332 {
 333     gmx_bool ret = TRUE;
 334     int      i, itmp;
 335
 336     gmx_fio_lock(fio);
 337     for (i = 0; i < n; i++)
 338     {
 339         if (fio->bRead)
 340         {
 341             ret = ret && fio->iotp->nread(fio, &itmp, 1, eioINT, desc,
 342                                           srcfile, line);
 343             item[i] = itmp;
 344         }
 345         else
 346         {
 347             itmp = item[i];
 348             ret  = ret && fio->iotp->nwrite(fio, &itmp, 1, eioINT, desc,
 349                                             srcfile, line);
 350         }
 351     }
 352     gmx_fio_unlock(fio);
 353     return ret;
 354 }
 355
 356 gmx_bool gmx_fio_ndoe_int(t_fileio *fio, int *item, int n,
 357                           const char *desc, const char *srcfile, int line)
 358 {
 359     gmx_bool ret = TRUE;
 360     int      i;
 361     gmx_fio_lock(fio);
 362     for (i = 0; i < n; i++)
 363     {
 364         if (fio->bRead)
 365         {
 366             ret = ret && fio->iotp->nread(fio, &(item[i]), 1, eioINT, desc,
 367                                           srcfile, line);
 368         }
 369         else
 370         {
 371             ret = ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioINT, desc,
 372                                            srcfile, line);
 373         }
 374     }
 375     gmx_fio_unlock(fio);
 376     return ret;
 377 }
 378
 379
 380
 381 gmx_bool gmx_fio_ndoe_int64(t_fileio *fio, gmx_int64_t *item, int n,
 382                             const char *desc, const char *srcfile, int line)
 383 {
 384     gmx_bool ret = TRUE;
 385     int      i;
 386     gmx_fio_lock(fio);
 387     for (i = 0; i < n; i++)
 388     {
 389         if (fio->bRead)
 390         {
 391             ret = ret && fio->iotp->nread(fio, &(item[i]), 1, eioINT64, desc,
 392                                           srcfile, line);
 393         }
 394         else
 395         {
 396             ret = ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioINT64, desc,
 397                                            srcfile, line);
 398         }
 399     }
 400     gmx_fio_unlock(fio);
 401     return ret;
 402 }
 403
 404
 405
 406 gmx_bool gmx_fio_ndoe_uchar(t_fileio *fio, unsigned char *item, int n,
 407                             const char *desc, const char *srcfile, int line)
 408 {
 409     gmx_bool ret = TRUE;
 410     gmx_fio_lock(fio);
 411     if (fio->bRead)
 412     {
 413         ret = ret && fio->iotp->nread(fio, item, n, eioNUCHAR, desc,
 414                                       srcfile, line);
 415     }
 416     else
 417     {
 418         ret = ret && fio->iotp->nwrite(fio, item, n, eioNUCHAR, desc,
 419                                        srcfile, line);
 420     }
 421     gmx_fio_unlock(fio);
 422     return ret;
 423 }
 424
 425
 426
 427 gmx_bool gmx_fio_ndoe_ushort(t_fileio *fio, unsigned short *item, int n,
 428                              const char *desc, const char *srcfile, int line)
 429 {
 430     gmx_bool ret = TRUE;
 431     int      i;
 432     gmx_fio_lock(fio);
 433     for (i = 0; i < n; i++)
 434     {
 435         if (fio->bRead)
 436         {
 437             ret = ret && fio->iotp->nread(fio, &(item[i]), 1, eioUSHORT, desc,
 438                                           srcfile, line);
 439         }
 440         else
 441         {
 442             ret = ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioUSHORT, desc,
 443                                            srcfile, line);
 444         }
 445     }
 446     gmx_fio_unlock(fio);
 447     return ret;
 448 }
 449
 450
 451
 452 gmx_bool gmx_fio_ndoe_rvec(t_fileio *fio, rvec *item, int n,
 453                            const char *desc, const char *srcfile, int line)
 454 {
 455     gmx_bool ret = TRUE;
 456     gmx_fio_lock(fio);
 457     if (fio->bRead)
 458     {
 459         ret = ret && fio->iotp->nread(fio, item, n, eioNRVEC, desc, srcfile, line);
 460     }
 461     else
 462     {
 463         ret = ret && fio->iotp->nwrite(fio, item, n, eioNRVEC, desc, srcfile,
 464                                        line);
 465     }
 466     gmx_fio_unlock(fio);
 467     return ret;
 468 }
 469
 470
 471
 472 gmx_bool gmx_fio_ndoe_ivec(t_fileio *fio, ivec *item, int n,
 473                            const char *desc, const char *srcfile, int line)
 474 {
 475     gmx_bool ret = TRUE;
 476     int      i;
 477     gmx_fio_lock(fio);
 478     for (i = 0; i < n; i++)
 479     {
 480         if (fio->bRead)
 481         {
 482             ret = ret && fio->iotp->nread(fio, &(item[i]), 1, eioIVEC, desc,
 483                                           srcfile, line);
 484         }
 485         else
 486         {
 487             ret = ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioIVEC, desc,
 488                                            srcfile, line);
 489         }
 490     }
 491     gmx_fio_unlock(fio);
 492     return ret;
 493 }
 494
 495
 496
 497 gmx_bool gmx_fio_ndoe_string(t_fileio *fio, char *item[], int n,
 498                              const char *desc, const char *srcfile, int line)
 499 {
 500     gmx_bool ret = TRUE;
 501     int      i;
 502     gmx_fio_lock(fio);
 503     for (i = 0; i < n; i++)
 504     {
 505         if (fio->bRead)
 506         {
 507             ret = ret && fio->iotp->nread(fio, &(item[i]), 1, eioSTRING, desc,
 508                                           srcfile, line);
 509         }
 510         else
 511         {
 512             ret = ret && fio->iotp->nwrite(fio, &(item[i]), 1, eioSTRING, desc,
 513                                            srcfile, line);
 514         }
 515     }
 516     gmx_fio_unlock(fio);
 517     return ret;
 518 }