/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * Copyright 1993, University Corporation for Atmospheric Research           *
 * See netcdf/COPYRIGHT file for copying and redistribution conditions.      *
 *                                                                           *
 * Copyright by The HDF Group.                                               *
 * Copyright by the Board of Trustees of the University of Illinois.         *
 * All rights reserved.                                                      *
 *                                                                           *
 * This file is part of HDF.  The full HDF copyright notice, including       *
 * terms governing use, modification, and redistribution, is contained in    *
 * the COPYING file, which can be found at the root of the source code       *
 * distribution tree, or in https://support.hdfgroup.org/ftp/HDF/releases/.  *
 * If you do not have access to either file, you may request a copy from     *
 * help@hdfgroup.org.                                                        *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

/*    $Id$ */

#include    "local_nc.h"
#include    "alloc.h"


NC_iarray *
NC_new_iarray(count, values)
unsigned count ;
const int *values ;           /* VAX C doesn't like values[] */
{
    NC_iarray *ret ;
    int *ip ;
    size_t memlen ;

    ret = (NC_iarray *)HDmalloc(sizeof(NC_iarray)) ;
    if( ret == NULL )
        goto alloc_err ;
    ret->count = count ;
    if(count != 0 ) /* allocate */
      {
          memlen = count * sizeof(int) ;
          ret->values = (int *)HDmalloc(memlen) ;
          if(ret->values == NULL)
              goto alloc_err ;
          if(values != NULL) /* copy them in */
            {
                for(ip = ret->values ; count > 0; count--)
                    *ip++ = *values++ ;
            }
      } else {
          ret->values = NULL ;
      }

    return(ret) ;
    alloc_err :
        nc_serror("NC_new_iarray") ;
    return(NULL) ;
}


/*
 * Free iarray, and, if needed, its values.
 *
 * NOTE: Changed return value to return 'int'
 *       If successful returns SUCCEED else FAIL -GV 9/19/97
 */
int
NC_free_iarray(iarray)
NC_iarray *iarray ;
{
    int ret_value = SUCCEED;

    if(iarray != NULL)
      {
          if(iarray->values != NULL)
              Free(iarray->values) ;
          Free(iarray) ;
      }

    return ret_value;
}


bool_t
xdr_NC_iarray(xdrs, ipp)
    XDR *xdrs;
    NC_iarray **ipp;
{
    int *ip ;
    u_long count = 0;
    bool_t stat = TRUE ;

    switch (xdrs->x_op) {
    case XDR_FREE:
        NC_free_iarray((*ipp)) ;
        return(TRUE) ;
    case XDR_DECODE:
        /* need the length to pass to new */
        if (! xdr_u_long(xdrs, &count)) {
            return (FALSE);
        }
        (*ipp) = NC_new_iarray((unsigned)count, (int *)NULL) ;
        if((*ipp) == NULL)
            return(FALSE) ;
        /* then deal with the array */
        for( ip = (*ipp)->values ; (count > 0 ) && stat ; count-- )
            stat = xdr_int(xdrs, ip++ ) ;
        return(stat) ;
    case XDR_ENCODE:
        /* first deal with the length */
        count = (*ipp)->count ;
        if (! xdr_u_long(xdrs, &count) ) {
            return (FALSE);
        }
        /* then deal with the array */
        for(ip = (*ipp)->values  ; (count > 0 ) && stat ; count--)
            stat = xdr_int(xdrs, ip++ ) ;
        return(stat) ;
    }
    return(FALSE) ;
}


/*
 * How much space will the xdr'd iarray take.
 */
int NC_xlen_iarray(iarray)
NC_iarray *iarray ;
{
    int len = 4 ;
    if(iarray!=NULL)
    {
        len += iarray->count * 4 ;
    }
    return(len) ;
}
