VectorSequenceFactories.c

Go to the documentation of this file.

/*----------------------------------------------------------------------- 

File Name: VectorSequenceFactories.c

<lalVerbatim file="VectorSequenceFactoriesCV">
Revision: $Id: VectorSequenceFactories.m4,v 1.4 2001/08/21 04:19:49 jolien Exp $
</lalVerbatim>

-------------------------------------------------------------------------*/

/* <lalLaTeX>

\subsection{Module \texttt{VectorSequenceFactories.c}}
\label{ss:VectorSequenceFactories.c}

Create/destroy $\langle\mbox{datatype}\rangle$VectorSequence objects. 

\subsubsection*{Prototypes}
\vspace{0.1in}
\input{VectorSequenceFactoriesD}
\idx{LALZCreateVectorSequence()}
\idx{LALCCreateVectorSequence()}
\idx{LALDCreateVectorSequence()}
\idx{LALSCreateVectorSequence()}
\idx{LALI2CreateVectorSequence()}
\idx{LALI4CreateVectorSequence()}
\idx{LALI8CreateVectorSequence()}
\idx{LALU2CreateVectorSequence()}
\idx{LALU4CreateVectorSequence()}
\idx{LALU8CreateVectorSequence()}
\idx{LALCHARCreateVectorSequence()}
\idx{LALCreateVectorSequence()}
\idx{LALZDestroyVectorSequence()}
\idx{LALCDestroyVectorSequence()}
\idx{LALDDestroyVectorSequence()}
\idx{LALSDestroyVectorSequence()}
\idx{LALI2DestroyVectorSequence()}
\idx{LALI4DestroyVectorSequence()}
\idx{LALI8DestroyVectorSequence()}
\idx{LALU2DestroyVectorSequence()}
\idx{LALU4DestroyVectorSequence()}
\idx{LALU8DestroyVectorSequence()}
\idx{LALCHARDestroyVectorSequence()}
\idx{LALDestroyVectorSequence()}

\subsubsection*{Description}

The \texttt{CreateVectorSequence} family of functions create a
$\langle\mbox{datatype}\rangle$\texttt{VectorSequence} of the
appropriate dimensions.

The \texttt{DestroyVectorSequence} family of functions return the storage
allocated by the \texttt{CreateVectorSequence} functions to the system.

\subsubsection*{Algorithm}

\subsubsection*{Uses}
\begin{verbatim}
LALMalloc()
LALFree()
\end{verbatim}

\subsubsection*{Notes}

\vfill{\footnotesize\input{VectorSequenceFactoriesCV}}

</lalLaTeX> */

#include "LALStdlib.h"
#include "SeqFactories.h"

/* <lalVerbatim file="VectorSequenceFactoriesNRCSID"> */
NRCSID( VECTORSEQUENCEFACTORIESC, "$Id: VectorSequenceFactories.m4,v 1.4 2001/08/21 04:19:49 jolien Exp $" );
/* </lalVerbatim> */
















  


COMPLEX16VectorSequence * XLALCreateCOMPLEX16VectorSequence ( UINT4 length, UINT4 veclen )
{
  COMPLEX16VectorSequence *seq;

  if ( ! length || ! veclen )
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX16VectorSequence", XLAL_EBADLEN );

  seq = LALMalloc( sizeof( *seq ) );
  if ( ! seq )
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX16VectorSequence", XLAL_ENOMEM );
  
  seq->length = length;
  seq->vectorLength = veclen;

  if ( ! length || ! veclen )
    seq->data = NULL;
  else
  {
    seq->data = LALMalloc( length * veclen * sizeof( *seq->data ) );
    if ( ! seq )
    {
      LALFree( seq );
      XLAL_ERROR_NULL( "XLALCreateCOMPLEX16VectorSequence", XLAL_ENOMEM );
    }
  }

  return seq;
}

/* <lalVerbatim file="VectorSequenceFactoriesD"> */
void LALZCreateVectorSequence ( LALStatus *status, COMPLEX16VectorSequence **vseq, CreateVectorSequenceIn *in ) 
{ /* </lalVerbatim> */
  /* 
   * Initialize status
   */
  INITSTATUS( status, "LALZCreateVectorSequence", VECTORSEQUENCEFACTORIESC );   

  /* Check input structure: report if NULL */

  ASSERT (in != NULL, status, SEQFACTORIESH_EINPTR, SEQFACTORIESH_MSGEINPTR);
      
  /* Check sequence length: report error if 0 
   * Use of unsigned for length means we can't check if negative
   * length was passed
   */

  ASSERT (in->length > 0, status,
          SEQFACTORIESH_ESLENGTH, SEQFACTORIESH_MSGESLENGTH);

  /* Check vector length: report error if 0 
   * Use of unsigned for length means we can't check if negative
   * length was passed
   */

  ASSERT (in->vectorLength > 0, status,
          SEQFACTORIESH_EVLENGTH, SEQFACTORIESH_MSGEVLENGTH); 

  /* 
   * Check return structure: If return pointer does not point to a
   *    valid pointer then report an error 
   */

  ASSERT (vseq != NULL, status, SEQFACTORIESH_EVPTR, SEQFACTORIESH_MSGEVPTR);
  ASSERT (*vseq == NULL, status, SEQFACTORIESH_EUPTR, SEQFACTORIESH_MSGEUPTR);


  *vseq = XLALCreateCOMPLEX16VectorSequence ( in->length, in->vectorLength );
  if ( ! vseq )
  {
    int code = xlalErrno;
    XLALClearErrno();
    if ( code == XLAL_EBADLEN )
    {
      if ( ! in->length )
      {
        ABORT (status, SEQFACTORIESH_ESLENGTH, SEQFACTORIESH_MSGESLENGTH);
      }
      else
      {
        ABORT (status, SEQFACTORIESH_EVLENGTH, SEQFACTORIESH_MSGEVLENGTH); 
      }
    }
    if ( code == XLAL_ENOMEM )
    {
      ABORT( status, SEQFACTORIESH_EMALLOC, SEQFACTORIESH_MSGEMALLOC );
    }
  }

  /* We be done: Normal exit */

  RETURN (status);
}















  

void XLALDestroyCOMPLEX16VectorSequence ( COMPLEX16VectorSequence *vseq )
{
  if ( ! vseq )
    return;
  if ( ( ! vseq->length || ! vseq->vectorLength ) && vseq->data )
    XLAL_ERROR_VOID( "XLALDestroyCOMPLEX16VectorSequence", XLAL_EINVAL );
  if ( ! vseq->data && ( vseq->length || vseq->vectorLength ) )
    XLAL_ERROR_VOID( "XLALDestroyCOMPLEX16VectorSequence", XLAL_EINVAL );
  if ( vseq->data )
    LALFree( vseq->data );
  vseq->data = NULL; /* leave lengths as they are to indicate freed vector */
  LALFree( vseq );
  return;
}

/* <lalVerbatim file="VectorSequenceFactoriesD"> */
void LALZDestroyVectorSequence ( LALStatus *status, COMPLEX16VectorSequence **vseq )
{ /* </lalVerbatim> */
  /* 
   * Initialize status
   */

  INITSTATUS( status, "LALZDestroyVectorSequence", VECTORSEQUENCEFACTORIESC );
      
  /* 
   * Check vseq: is it non-NULL?
   */

  ASSERT (vseq != NULL, status, SEQFACTORIESH_EVPTR, SEQFACTORIESH_MSGEVPTR); 

  /* 
   * Check vseq: does it point to non-NULL?
   */

  ASSERT (*vseq != NULL,status, SEQFACTORIESH_EUPTR, SEQFACTORIESH_MSGEUPTR);

  /*
   * Check data in vseq: does it point to non-NULL?
   */

  ASSERT ((*vseq)->data != NULL, status,
          SEQFACTORIESH_EDPTR, SEQFACTORIESH_MSGEDPTR);

  /* Ok, now let's free allocated storage */

  XLALDestroyCOMPLEX16VectorSequence ( *vseq );
  if ( xlalErrno )
  {
    int code = xlalErrno;
    XLALClearErrno();
    if ( code == XLAL_EFAULT )
    {
      ABORT (status, SEQFACTORIESH_EUPTR, SEQFACTORIESH_MSGEUPTR);
    }
    if ( code == XLAL_EINVAL )
    {
      ABORT (status, SEQFACTORIESH_EDPTR, SEQFACTORIESH_MSGEDPTR);
    }
  }

  *vseq = NULL;         /* make sure we don't point to freed struct */

  RETURN (status);
}

















  


COMPLEX8VectorSequence * XLALCreateCOMPLEX8VectorSequence ( UINT4 length, UINT4 veclen )
{
  COMPLEX8VectorSequence *seq;

  if ( ! length || ! veclen )
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX8VectorSequence", XLAL_EBADLEN );

  seq = LALMalloc( sizeof( *seq ) );
  if ( ! seq )
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX8VectorSequence", XLAL_ENOMEM );
  
  seq->length = length;
  seq->vectorLength = veclen;

  if ( ! length || ! veclen )
    seq->data = NULL;
  else
  {
    seq->data = LALMalloc( length * veclen * sizeof( *seq->data ) );
    if ( ! seq )
    {
      LALFree( seq );
      XLAL_ERROR_NULL( "XLALCreateCOMPLEX8VectorSequence", XLAL_ENOMEM );
    }
  }

  return seq;
}

/* <lalVerbatim file="VectorSequenceFactoriesD"> */
void LALCCreateVectorSequence ( LALStatus *status, COMPLEX8VectorSequence **vseq, CreateVectorSequenceIn *in ) 
{ /* </lalVerbatim> */
  /* 
   * Initialize status
   */
  INITSTATUS( status, "LALCCreateVectorSequence", VECTORSEQUENCEFACTORIESC );   

  /* Check input structure: report if NULL */

  ASSERT (in != NULL, status, SEQFACTORIESH_EINPTR, SEQFACTORIESH_MSGEINPTR);
      
  /* Check sequence length: report error if 0 
   * Use of unsigned for length means we can't check if negative
   * length was passed
   */

  ASSERT (in->length > 0, status,
          SEQFACTORIESH_ESLENGTH, SEQFACTORIESH_MSGESLENGTH);

  /* Check vector length: report error if 0 
   * Use of unsigned for length means we can't check if negative
   * length was passed
   */

  ASSERT (in->vectorLength > 0, status,
          SEQFACTORIESH_EVLENGTH, SEQFACTORIESH_MSGEVLENGTH); 

  /* 
   * Check return structure: If return pointer does not point to a
   *    valid pointer then report an error 
   */

  ASSERT (vseq != NULL, status, SEQFACTORIESH_EVPTR, SEQFACTORIESH_MSGEVPTR);
  ASSERT (*vseq == NULL, status, SEQFACTORIESH_EUPTR, SEQFACTORIESH_MSGEUPTR);


  *vseq = XLALCreateCOMPLEX8VectorSequence ( in->length, in->vectorLength );
  if ( ! vseq )
  {
    int code = xlalErrno;
    XLALClearErrno();
    if ( code == XLAL_EBADLEN )
    {
      if ( ! in->length )
      {
        ABORT (status, SEQFACTORIESH_ESLENGTH, SEQFACTORIESH_MSGESLENGTH);
      }
      else
      {
        ABORT (status, SEQFACTORIESH_EVLENGTH, SEQFACTORIESH_MSGEVLENGTH); 
      }
    }
    if ( code == XLAL_ENOMEM )
    {
      ABORT( status, SEQFACTORIESH_EMALLOC, SEQFACTORIESH_MSGEMALLOC );
    }
  }

  /* We be done: Normal exit */

  RETURN (status);
}















  

void XLALDestroyCOMPLEX8VectorSequence ( COMPLEX8VectorSequence *vseq )
{
  if ( ! vseq )
    return;
  if ( ( ! vseq->length || ! vseq->vectorLength ) && vseq->data )
    XLAL_ERROR_VOID( "XLALDestroyCOMPLEX8VectorSequence", XLAL_EINVAL );
  if ( ! vseq->data && ( vseq->length || vseq->vectorLength ) )
    XLAL_ERROR_VOID( "XLALDestroyCOMPLEX8VectorSequence", XLAL_EINVAL );
  if ( vseq->data )
    LALFree( vseq->data );
  vseq->data = NULL; /* leave lengths as they are to indicate freed vector */
  LALFree( vseq );
  return;
}

/* <lalVerbatim file="VectorSequenceFactoriesD"> */
void LALCDestroyVectorSequence ( LALStatus *status, COMPLEX8VectorSequence **vseq )
{ /* </lalVerbatim> */
  /* 
   * Initialize status
   */

  INITSTATUS( status, "LALCDestroyVectorSequence", VECTORSEQUENCEFACTORIESC );
      
  /* 
   * Check vseq: is it non-NULL?
   */

  ASSERT (vseq != NULL, status, SEQFACTORIESH_EVPTR, SEQFACTORIESH_MSGEVPTR); 

  /* 
   * Check vseq: does it point to non-NULL?
   */

  ASSERT (*vseq != NULL,status, SEQFACTORIESH_EUPTR, SEQFACTORIESH_MSGEUPTR);

  /*
   * Check data in vseq: does it point to non-NULL?
   */

  ASSERT ((*vseq)->data != NULL, status,
          SEQFACTORIESH_EDPTR, SEQFACTORIESH_MSGEDPTR);

  /* Ok, now let's free allocated storage */

  XLALDestroyCOMPLEX8VectorSequence ( *vseq );
  if ( xlalErrno )
  {
    int code = xlalErrno;
    XLALClearErrno();
    if ( code == XLAL_EFAULT )
    {
      ABORT (status, SEQFACTORIESH_EUPTR, SEQFACTORIESH_MSGEUPTR);
    }
    if ( code == XLAL_EINVAL )
    {
      ABORT (status, SEQFACTORIESH_EDPTR, SEQFACTORIESH_MSGEDPTR);
    }
  }

  *vseq = NULL;         /* make sure we don't point to freed struct */

  RETURN (status);
}

















  


REAL8VectorSequence * XLALCreateREAL8VectorSequence ( UINT4 length, UINT4 veclen )
{
  REAL8VectorSequence *seq;

  if ( ! length || ! veclen )
    XLAL_ERROR_NULL( "XLALCreateREAL8VectorSequence", XLAL_EBADLEN );

  seq = LALMalloc( sizeof( *seq ) );
  if ( ! seq )
    XLAL_ERROR_NULL( "XLALCreateREAL8VectorSequence", XLAL_ENOMEM );
  
  seq->length = length;
  seq->vectorLength = veclen;

  if ( ! length || ! veclen )
    seq->data = NULL;
  else
  {
    seq->data = LALMalloc( length * veclen * sizeof( *seq->data ) );
    if ( ! seq )
    {
      LALFree( seq );
      XLAL_ERROR_NULL( "XLALCreateREAL8VectorSequence", XLAL_ENOMEM );
    }
  }

  return seq;
}

/* <lalVerbatim file="VectorSequenceFactoriesD"> */
void LALDCreateVectorSequence ( LALStatus *status, REAL8VectorSequence **vseq, CreateVectorSequenceIn *in ) 
{ /* </lalVerbatim> */
  /* 
   * Initialize status
   */
  INITSTATUS( status, "LALDCreateVectorSequence", VECTORSEQUENCEFACTORIESC );   

  /* Check input structure: report if NULL */

  ASSERT (in != NULL, status, SEQFACTORIESH_EINPTR, SEQFACTORIESH_MSGEINPTR);
      
  /* Check sequence length: report error if 0 
   * Use of unsigned for length means we can't check if negative
   * length was passed
   */

  ASSERT (in->length > 0, status,
          SEQFACTORIESH_ESLENGTH, SEQFACTORIESH_MSGESLENGTH);

  /* Check vector length: report error if 0 
   * Use of unsigned for length means we can't check if negative
   * length was passed
   */

  ASSERT (in->vectorLength > 0, status,
          SEQFACTORIESH_EVLENGTH, SEQFACTORIESH_MSGEVLENGTH); 

  /* 
   * Check return structure: If return pointer does not point to a
   *    valid pointer then report an error 
   */

  ASSERT (vseq != NULL, status, SEQFACTORIESH_EVPTR, SEQFACTORIESH_MSGEVPTR);
  ASSERT (*vseq == NULL, status, SEQFACTORIESH_EUPTR, SEQFACTORIESH_MSGEUPTR);


  *vseq = XLALCreateREAL8VectorSequence ( in->length, in->vectorLength );
  if ( ! vseq )
  {
    int code = xlalErrno;
    XLALClearErrno();
    if ( code == XLAL_EBADLEN )
    {
      if ( ! in->length )
      {
        ABORT (status, SEQFACTORIESH_ESLENGTH, SEQFACTORIESH_MSGESLENGTH);
      }
      else
      {
        ABORT (status, SEQFACTORIESH_EVLENGTH, SEQFACTORIESH_MSGEVLENGTH); 
      }
    }
    if ( code == XLAL_ENOMEM )
    {
      ABORT( status, SEQFACTORIESH_EMALLOC, SEQFACTORIESH_MSGEMALLOC );
    }
  }

  /* We be done: Normal exit */

  RETURN (status);
}















  

void XLALDestroyREAL8VectorSequence ( REAL8VectorSequence *vseq )
{
  if ( ! vseq )
    return;
  if ( ( ! vseq->length || ! vseq->vectorLength ) && vseq->data )
    XLAL_ERROR_VOID( "XLALDestroyREAL8VectorSequence", XLAL_EINVAL );
  if ( ! vseq->data && ( vseq->length || vseq->vectorLength ) )
    XLAL_ERROR_VOID( "XLALDestroyREAL8VectorSequence", XLAL_EINVAL );
  if ( vseq->data )
    LALFree( vseq->data );
  vseq->data = NULL; /* leave lengths as they are to indicate freed vector */
  LALFree( vseq );
  return;
}

/* <lalVerbatim file="VectorSequenceFactoriesD"> */
void LALDDestroyVectorSequence ( LALStatus *status, REAL8VectorSequence **vseq )
{ /* </lalVerbatim> */
  /* 
   * Initialize status
   */

  INITSTATUS( status, "LALDDestroyVectorSequence", VECTORSEQUENCEFACTORIESC );
      
  /* 
   * Check vseq: is it non-NULL?
   */

  ASSERT (vseq != NULL, status, SEQFACTORIESH_EVPTR, SEQFACTORIESH_MSGEVPTR); 

  /* 
   * Check vseq: does it point to non-NULL?
   */

  ASSERT (*vseq != NULL,status, SEQFACTORIESH_EUPTR, SEQFACTORIESH_MSGEUPTR);

  /*
   * Check data in vseq: does it point to non-NULL?
   */

  ASSERT ((*vseq)->data != NULL, status,
          SEQFACTORIESH_EDPTR, SEQFACTORIESH_MSGEDPTR);

  /* Ok, now let's free allocated storage */

  XLALDestroyREAL8VectorSequence ( *vseq );
  if ( xlalErrno )
  {
    int code = xlalErrno;
    XLALClearErrno();
    if ( code == XLAL_EFAULT )
    {
      ABORT (status, SEQFACTORIESH_EUPTR, SEQFACTORIESH_MSGEUPTR);
    }
    if ( code == XLAL_EINVAL )
    {
      ABORT (status, SEQFACTORIESH_EDPTR, SEQFACTORIESH_MSGEDPTR);
    }
  }

  *vseq = NULL;         /* make sure we don't point to freed struct */

  RETURN (status);
}

















  


REAL4VectorSequence * XLALCreateREAL4VectorSequence ( UINT4 length, UINT4 veclen )
{
  REAL4VectorSequence *seq;

  if ( ! length || ! veclen )
    XLAL_ERROR_NULL( "XLALCreateREAL4VectorSequence", XLAL_EBADLEN );

  seq = LALMalloc( sizeof( *seq ) );
  if ( ! seq )
    XLAL_ERROR_NULL( "XLALCreateREAL4VectorSequence", XLAL_ENOMEM );
  
  seq->length = length;
  seq->vectorLength = veclen;

  if ( ! length || ! veclen )
    seq->data = NULL;
  else
  {
    seq->data = LALMalloc( length * veclen * sizeof( *seq->data ) );
    if ( ! seq )
    {
      LALFree( seq );
      XLAL_ERROR_NULL( "XLALCreateREAL4VectorSequence", XLAL_ENOMEM );
    }
  }

  return seq;
}

/* <lalVerbatim file="VectorSequenceFactoriesD"> */
void LALSCreateVectorSequence ( LALStatus *status, REAL4VectorSequence **vseq, CreateVectorSequenceIn *in ) 
{ /* </lalVerbatim> */
  /* 
   * Initialize status
   */
  INITSTATUS( status, "LALSCreateVectorSequence", VECTORSEQUENCEFACTORIESC );   

  /* Check input structure: report if NULL */

  ASSERT (in != NULL, status, SEQFACTORIESH_EINPTR, SEQFACTORIESH_MSGEINPTR);
      
  /* Check sequence length: report error if 0 
   * Use of unsigned for length means we can't check if negative
   * length was passed
   */

  ASSERT (in->length > 0, status,
          SEQFACTORIESH_ESLENGTH, SEQFACTORIESH_MSGESLENGTH);

  /* Check vector length: report error if 0 
   * Use of unsigned for length means we can't check if negative
   * length was passed
   */

  ASSERT (in->vectorLength > 0, status,
          SEQFACTORIESH_EVLENGTH, SEQFACTORIESH_MSGEVLENGTH); 

  /* 
   * Check return structure: If return pointer does not point to a
   *    valid pointer then report an error 
   */

  ASSERT (vseq != NULL, status, SEQFACTORIESH_EVPTR, SEQFACTORIESH_MSGEVPTR);
  ASSERT (*vseq == NULL, status, SEQFACTORIESH_EUPTR, SEQFACTORIESH_MSGEUPTR);


  *vseq = XLALCreateREAL4VectorSequence ( in->length, in->vectorLength );
  if ( ! vseq )
  {
    int code = xlalErrno;
    XLALClearErrno();
    if ( code == XLAL_EBADLEN )
    {
      if ( ! in->length )
      {
        ABORT (status, SEQFACTORIESH_ESLENGTH, SEQFACTORIESH_MSGESLENGTH);
      }
      else
      {
        ABORT (status, SEQFACTORIESH_EVLENGTH, SEQFACTORIESH_MSGEVLENGTH); 
      }
    }
    if ( code == XLAL_ENOMEM )
    {
      ABORT( status, SEQFACTORIESH_EMALLOC, SEQFACTORIESH_MSGEMALLOC );
    }
  }

  /* We be done: Normal exit */

  RETURN (status);
}















  

void XLALDestroyREAL4VectorSequence ( REAL4VectorSequence *vseq )
{
  if ( ! vseq )
    return;
  if ( ( ! vseq->length || ! vseq->vectorLength ) && vseq->data )
    XLAL_ERROR_VOID( "XLALDestroyREAL4VectorSequence", XLAL_EINVAL );
  if ( ! vseq->data && ( vseq->length || vseq->vectorLength ) )
    XLAL_ERROR_VOID( "XLALDestroyREAL4VectorSequence", XLAL_EINVAL );
  if ( vseq->data )
    LALFree( vseq->data );
  vseq->data = NULL; /* leave lengths as they are to indicate freed vector */
  LALFree( vseq );
  return;
}

/* <lalVerbatim file="VectorSequenceFactoriesD"> */
void LALSDestroyVectorSequence ( LALStatus *status, REAL4VectorSequence **vseq )
{ /* </lalVerbatim> */
  /* 
   * Initialize status
   */

  INITSTATUS( status, "LALSDestroyVectorSequence", VECTORSEQUENCEFACTORIESC );
      
  /* 
   * Check vseq: is it non-NULL?
   */

  ASSERT (vseq != NULL, status, SEQFACTORIESH_EVPTR, SEQFACTORIESH_MSGEVPTR); 

  /* 
   * Check vseq: does it point to non-NULL?
   */

  ASSERT (*vseq != NULL,status, SEQFACTORIESH_EUPTR, SEQFACTORIESH_MSGEUPTR);

  /*
   * Check data in vseq: does it point to non-NULL?
   */

  ASSERT ((*vseq)->data != NULL, status,
          SEQFACTORIESH_EDPTR, SEQFACTORIESH_MSGEDPTR);

  /* Ok, now let's free allocated storage */

  XLALDestroyREAL4VectorSequence ( *vseq );
  if ( xlalErrno )
  {
    int code = xlalErrno;
    XLALClearErrno();
    if ( code == XLAL_EFAULT )
    {
      ABORT (status, SEQFACTORIESH_EUPTR, SEQFACTORIESH_MSGEUPTR);
    }
    if ( code == XLAL_EINVAL )
    {
      ABORT (status, SEQFACTORIESH_EDPTR, SEQFACTORIESH_MSGEDPTR);
    }
  }

  *vseq = NULL;         /* make sure we don't point to freed struct */

  RETURN (status);
}

















  


INT2VectorSequence * XLALCreateINT2VectorSequence ( UINT4 length, UINT4 veclen )
{
  INT2VectorSequence *seq;

  if ( ! length || ! veclen )
    XLAL_ERROR_NULL( "XLALCreateINT2VectorSequence", XLAL_EBADLEN );

  seq = LALMalloc( sizeof( *seq ) );
  if ( ! seq )
    XLAL_ERROR_NULL( "XLALCreateINT2VectorSequence", XLAL_ENOMEM );
  
  seq->length = length;
  seq->vectorLength = veclen;

  if ( ! length || ! veclen )
    seq->data = NULL;
  else
  {
    seq->data = LALMalloc( length * veclen * sizeof( *seq->data ) );
    if ( ! seq )
    {
      LALFree( seq );
      XLAL_ERROR_NULL( "XLALCreateINT2VectorSequence", XLAL_ENOMEM );
    }
  }

  return seq;
}

/* <lalVerbatim file="VectorSequenceFactoriesD"> */
void LALI2CreateVectorSequence ( LALStatus *status, INT2VectorSequence **vseq, CreateVectorSequenceIn *in ) 
{ /* </lalVerbatim> */
  /* 
   * Initialize status
   */
  INITSTATUS( status, "LALI2CreateVectorSequence", VECTORSEQUENCEFACTORIESC );  

  /* Check input structure: report if NULL */

  ASSERT (in != NULL, status, SEQFACTORIESH_EINPTR, SEQFACTORIESH_MSGEINPTR);
      
  /* Check sequence length: report error if 0 
   * Use of unsigned for length means we can't check if negative
   * length was passed
   */

  ASSERT (in->length > 0, status,
          SEQFACTORIESH_ESLENGTH, SEQFACTORIESH_MSGESLENGTH);

  /* Check vector length: report error if 0 
   * Use of unsigned for length means we can't check if negative
   * length was passed
   */

  ASSERT (in->vectorLength > 0, status,
          SEQFACTORIESH_EVLENGTH, SEQFACTORIESH_MSGEVLENGTH); 

  /* 
   * Check return structure: If return pointer does not point to a
   *    valid pointer then report an error 
   */

  ASSERT (vseq != NULL, status, SEQFACTORIESH_EVPTR, SEQFACTORIESH_MSGEVPTR);
  ASSERT (*vseq == NULL, status, SEQFACTORIESH_EUPTR, SEQFACTORIESH_MSGEUPTR);


  *vseq = XLALCreateINT2VectorSequence ( in->length, in->vectorLength );
  if ( ! vseq )
  {
    int code = xlalErrno;
    XLALClearErrno();
    if ( code == XLAL_EBADLEN )
    {
      if ( ! in->length )
      {
        ABORT (status, SEQFACTORIESH_ESLENGTH, SEQFACTORIESH_MSGESLENGTH);
      }
      else
      {
        ABORT (status, SEQFACTORIESH_EVLENGTH, SEQFACTORIESH_MSGEVLENGTH); 
      }
    }
    if ( code == XLAL_ENOMEM )
    {
      ABORT( status, SEQFACTORIESH_EMALLOC, SEQFACTORIESH_MSGEMALLOC );
    }
  }

  /* We be done: Normal exit */

  RETURN (status);
}















  

void XLALDestroyINT2VectorSequence ( INT2VectorSequence *vseq )
{
  if ( ! vseq )
    return;
  if ( ( ! vseq->length || ! vseq->vectorLength ) && vseq->data )
    XLAL_ERROR_VOID( "XLALDestroyINT2VectorSequence", XLAL_EINVAL );
  if ( ! vseq->data && ( vseq->length || vseq->vectorLength ) )
    XLAL_ERROR_VOID( "XLALDestroyINT2VectorSequence", XLAL_EINVAL );
  if ( vseq->data )
    LALFree( vseq->data );
  vseq->data = NULL; /* leave lengths as they are to indicate freed vector */
  LALFree( vseq );
  return;
}

/* <lalVerbatim file="VectorSequenceFactoriesD"> */
void LALI2DestroyVectorSequence ( LALStatus *status, INT2VectorSequence **vseq )
{ /* </lalVerbatim> */
  /* 
   * Initialize status
   */

  INITSTATUS( status, "LALI2DestroyVectorSequence", VECTORSEQUENCEFACTORIESC );
      
  /* 
   * Check vseq: is it non-NULL?
   */

  ASSERT (vseq != NULL, status, SEQFACTORIESH_EVPTR, SEQFACTORIESH_MSGEVPTR); 

  /* 
   * Check vseq: does it point to non-NULL?
   */

  ASSERT (*vseq != NULL,status, SEQFACTORIESH_EUPTR, SEQFACTORIESH_MSGEUPTR);

  /*
   * Check data in vseq: does it point to non-NULL?
   */

  ASSERT ((*vseq)->data != NULL, status,
          SEQFACTORIESH_EDPTR, SEQFACTORIESH_MSGEDPTR);

  /* Ok, now let's free allocated storage */

  XLALDestroyINT2VectorSequence ( *vseq );
  if ( xlalErrno )
  {
    int code = xlalErrno;
    XLALClearErrno();
    if ( code == XLAL_EFAULT )
    {
      ABORT (status, SEQFACTORIESH_EUPTR, SEQFACTORIESH_MSGEUPTR);
    }
    if ( code == XLAL_EINVAL )
    {
      ABORT (status, SEQFACTORIESH_EDPTR, SEQFACTORIESH_MSGEDPTR);
    }
  }

  *vseq = NULL;         /* make sure we don't point to freed struct */

  RETURN (status);
}