---

ccp4_array.h

Go to the documentation of this file.

/*
     ccp4_array.h: header file for resizable array implementation. 
     Copyright (C) 2002  Kevin Cowtan

     This library is free software and is distributed under the terms and
     conditions of the CCP4 licence agreement as `Part 0' (Annex 2)
     software, which is version 2.1 of the GNU Lesser General Public
     Licence (LGPL) with the following additional clause:

        `You may also combine or link a "work that uses the Library" to
        produce a work containing portions of the Library, and distribute
        that work under terms of your choice, provided that you give
        prominent notice with each copy of the work that the specified
        version of the Library is used in it, and that you include or
        provide public access to the complete corresponding
        machine-readable source code for the Library including whatever
        changes were used in the work. (i.e. If you make changes to the
        Library you must distribute those, but you do not need to
        distribute source or object code to those portions of the work
        not covered by this licence.)'

     Note that this clause grants an additional right and does not impose
     any additional restriction, and so does not affect compatibility
     with the GNU General Public Licence (GPL). If you wish to negotiate
     other terms, please contact the maintainer.

     You can redistribute it and/or modify the library under the terms of
     the GNU Lesser General Public License as published by the Free Software
     Foundation; either version 2.1 of the License, or (at your option) any
     later version.

     This library is distributed in the hope that it will be useful, but
     WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Lesser General Public License for more details.

     You should have received a copy of the CCP4 licence and/or GNU
     Lesser General Public License along with this library; if not, write
     to the CCP4 Secretary, Daresbury Laboratory, Warrington WA4 4AD, UK.
     The GNU Lesser General Public can also be obtained by writing to the
     Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
     MA 02111-1307 USA
*/

/*
CCP4 resizable array implementation.

This defines an object and methods which looks just like a simple C
array, but can be resized at will without incurring excessive
overheads.

A pointer to the desired type is created. Array elements are accessed
from this pointer as normal. Other operations depend on macros which
extract the stored type from the type of the pointer.

The array is managed with a header, which is positioned before the
beginning of the array. The malloc'ed memory area starts at the
beginning of this header. However the pointer to the header is not
stored, but rather derived from the array pointer whenever it is
required.

Arrays have a size and a capacity. The size is the number of elements
in use, and the capacity is the number of elements available before a
new memory allocation is required. When new memory is required, an
excess is reqested to allow the array to grow further before
performing another malloc.

If the precise amount of memory is known, the capacity can be
controlled directly using the 'reserve' macro.

Example: to handle an array of type mytype:

\code
  int i;
  mytype x,y;
  mytype *array;

  ccp4array_new(array);

  ccp4array_append_n(array, x, 3);

  for ( i = 0; i < 3; i++ ) y = array[i];

  ccp4array_free(array);
\endcode
*/

#ifndef __CCP4_ARRAY_INC
#define __CCP4_ARRAY_INC

#ifdef  __cplusplus
extern "C" {
#endif

#include <stdlib.h>
#include <string.h>
static char rcsidha[] = "$Id: ccp4__array_8h-source.html,v 1.8 2004/07/05 14:36:54 mdw Exp $";

typedef const void *ccp4_constptr;
typedef char *ccp4_byteptr;
typedef void *ccp4_ptr;

typedef struct ccp4array_base_ {
  int size, capacity;
} ccp4array_base;

#define ccp4array_new(v) ccp4array_new_((ccp4_ptr*)(&v))

#define ccp4array_new_size(v,s) ccp4array_new_size_((ccp4_ptr*)(&v),s,sizeof(*v))

#define ccp4array_resize(v,s) ccp4array_resize_((ccp4_ptr*)(&v),s,sizeof(*v))

#define ccp4array_reserve(v,s) ccp4array_reserve_((ccp4_ptr*)(&v),s,sizeof(*v))

#define ccp4array_append(v,d) ccp4array_append_((ccp4_ptr*)(&v),(ccp4_constptr)(&d),sizeof(*v))

#define ccp4array_append_n(v,d,n) ccp4array_append_n_((ccp4_ptr*)(&v),(ccp4_constptr)(&d),n,sizeof(*v))

#define ccp4array_append_list(v,l,n) ccp4array_append_list_((ccp4_ptr*)(&v),(ccp4_constptr)l,n,sizeof(*v))

#define ccp4array_insert(v,i,d) ccp4array_insert_((ccp4_ptr*)(&v),i,(ccp4_constptr)(&d),sizeof(*v))

#define ccp4array_delete_ordered(v,i) ccp4array_delete_ordered_((ccp4_ptr*)(&v),i,sizeof(*v))

#define ccp4array_delete(v,i) ccp4array_delete_((ccp4_ptr*)(&v),i,sizeof(*v))

#define ccp4array_delete_last(v) ccp4array_delete_last_((ccp4_ptr*)(&v),sizeof(*v))

#define ccp4array_size(v) ccp4array_size_((ccp4_constptr*)(&v))

#define ccp4array_free(v) ccp4array_free_((ccp4_ptr*)(&v))

ccp4_ptr ccp4array_new_(ccp4_ptr *p);
ccp4_ptr ccp4array_new_size_(ccp4_ptr *p, const int size, const size_t reclen);
void ccp4array_resize_(ccp4_ptr *p, const int size, const size_t reclen);
void ccp4array_reserve_(ccp4_ptr *p, const int size, const size_t reclen);
void ccp4array_append_(ccp4_ptr *p, ccp4_constptr data, const size_t reclen);
void ccp4array_append_n_(ccp4_ptr *p, ccp4_constptr data, const int n, const size_t reclen);
void ccp4array_append_list_(ccp4_ptr *p, ccp4_constptr data, const int n, const size_t reclen);
void ccp4array_insert_(ccp4_ptr *p, const int i, ccp4_constptr data, const size_t reclen);
void ccp4array_delete_ordered_(ccp4_ptr *p, const int i, const size_t reclen);
void ccp4array_delete_(ccp4_ptr *p, const int i, const size_t reclen);
void ccp4array_delete_last_(ccp4_ptr *p, const size_t reclen);
int ccp4array_size_(ccp4_constptr *p);
void ccp4array_free_(ccp4_ptr *p);

#ifdef __cplusplus
} 
#endif

#endif /* __CCP4_ARRAY_INC */