SeqFactories.h

Go to the documentation of this file.

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

File Name: SeqFactories.h

<lalVerbatim file="SeqFactoriesHV">
Revision: $Id: SeqFactoriesH.m4,v 1.3 2004/11/10 20:41:21 jolien Exp $
</lalVerbatim>

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

/* <lalLaTeX>

\section{Header \texttt{SeqFactories.h}}
\label{s:SeqFactories.h}

Provides prototype and status code information for use of CreateVectorSequence
and DestroyVectorSequence.

\subsection*{Synopsis}
\begin{verbatim}
#include <lal/SeqFactories.h>
\end{verbatim}

</lalLaTeX> */

#ifndef _SEQFACTORIES_H
#define _SEQFACTORIES_H

#include <lal/LALDatatypes.h>
#include <lal/AVFactories.h>

#ifdef  __cplusplus
extern "C" {
#endif

NRCSID (SEQFACTORIESH, "$Id: SeqFactoriesH.m4,v 1.3 2004/11/10 20:41:21 jolien Exp $");

/* <lalLaTeX>

\subsection*{Error conditions}
\input{SeqFactoriesHErrTab}

</lalLaTeX> */

/*
<lalErrTable file="SeqFactoriesHErrTab">
*/

#define SEQFACTORIESH_ESLENGTH  1
#define SEQFACTORIESH_EVLENGTH  2
#define SEQFACTORIESH_EALENGTH  4
#define SEQFACTORIESH_EVPTR     8
#define SEQFACTORIESH_EUPTR    16
#define SEQFACTORIESH_EDPTR    32
#define SEQFACTORIESH_EINPTR   64
#define SEQFACTORIESH_EMALLOC 128

#define SEQFACTORIESH_MSGESLENGTH "Illegal sequence length."
#define SEQFACTORIESH_MSGEVLENGTH "Illegal vector length."
#define SEQFACTORIESH_MSGEALENGTH "Illegal array dimension."
#define SEQFACTORIESH_MSGEVPTR    "Null sequence handle."
#define SEQFACTORIESH_MSGEUPTR    "Non-null sequence pointer."
#define SEQFACTORIESH_MSGEDPTR    "Null sequence data."
#define SEQFACTORIESH_MSGEINPTR   "Null input pointer."
#define SEQFACTORIESH_MSGEMALLOC  "Malloc failure."

/*
</lalErrTable>
*/


/* Structures. */
/* <lalLaTeX>

\subsection*{Structures}
\begin{verbatim}
CreateVectorSequenceIn
\end{verbatim}
\idx[Type]{CreateVectorSequenceIn}

\noindent This structure stores the input required for creating a vector
sequence.  This input includes the length of the sequence (i.e., the number of
vectors) and the length of each vector.  The fields are:

\begin{description}
\item[\texttt{UINT4 length}] The sequence length.
\item[\texttt{UINT4 vectorLength}] The length of each vector in the sequence.
\end{description}

</lalLaTeX> */

typedef struct tagCreateVectorSequenceIn {
  UINT4 length;
  UINT4 vectorLength;
} CreateVectorSequenceIn;


/* <lalLaTeX>

\begin{verbatim}
CreateArraySequenceIn
\end{verbatim}
\idx[Type]{CreateArraySequenceIn}

\noindent This structure stores the input required for creating an array
sequence.  This input includes the length of the sequence (i.e., the number of
array) and the dimensions of each array index.  The fields are:

\begin{description}
\item[\texttt{UINT4 length}] The sequence length.
\item[\texttt{UINT4Vector *dimLength}] The dimensions of each array
index (the same for every array in the sequence).
\end{description}

</lalLaTeX> */

typedef struct tagCreateArraySequenceIn {
  UINT4 length;
  UINT4Vector *dimLength;
} CreateArraySequenceIn;


/* Function prototypes. */
/* <lalLaTeX>
\newpage\input{VectorSequenceFactoriesC}

\newpage
\subsection{XLAL Functions}

\subsubsection*{Synopsis}
\begin{verbatim}
REAL4VectorSequence * XLALCreateVectorSequence(UINT4 length, UINT4 veclen);
void XLALCreateVectorSequence(REAL4VectorSequence *vecseq);

<vecseqtype> * XLALCreate<vecseqtype>(UINT4 length, UINT4 veclen);
void XLALCreate<vecseqtype>(<vecseqtype> *vecseq);
\end{verbatim}
\idx{XLALCreateREAL4VectorSequence}
\idx{XLALDestroyREAL4VectorSequence}
\idx{XLALCreate<type>VectorSequence}
\idx{XLALDestroy<type>VectorSequence}

Here \verb+<vecseqtype>+ is one of
\verb+COMPLEX16VectorSequence+,
\verb+COMPLEX8VectorSequence+,
\verb+REAL8VectorSequence+,
\verb+REAL4VectorSequence+,
\verb+INT8VectorSequence+,
\verb+INT4VectorSequence+,
\verb+INT2VectorSequence+,
\verb+UINT8VectorSequence+,
\verb+UINT4VectorSequence+,
\verb+UINT2VectorSequence+, or
\verb+CHARVectorSequence+.

\subsubsection*{Description}

The \verb+XLALCreate<type>VectorSequence+ functions create vector sequences
of type \verb+<type>, length \verb+length+, and vector length \verb+veclen+.
The function \verb+XLALCreateVectorSequence+ is the same as
\verb+XLALCreateREAL4VectorSequence+.

The \verb+XLALDestroy<type>VectorSequence+ functions deallocate the memory
allocation pointed to by \verb+vecseq+ including its contents.  The function
\verb+XLALDestroyVectorSequence+ is the same as
\verb+XLALDestroyREAL4VectorSequence+.

\subsubsection*{Return Values}

The create functions return a pointer to the created vector sequence if
successful; upon failure they will return \verb+NULL+ and set \verb+xlalErrno+
to one of the following values: \verb+XLAL_ENOMEM+ if memory allocation
failed, or \verb+XLAL_EBADLEN+ if the requested \verb+length+ or \verb+veclen+
is zero.

The destroy functions do not have a return value.  They can fail if they are
passed a \verb+NULL+ pointer, in which case \verb+xlalErrno+ is set to
\verb+XLAL_EFAULT+, or if the vector sequency passed to the destroy routine
has zero length, vector length, or \verb+NULL+ data pointer then
\verb+xlalErrno+ is set to \verb+XLAL_EINVAL+.


</lalLaTeX> */

REAL4VectorSequence * XLALCreateVectorSequence ( UINT4 length, UINT4 veclen );
void XLALDestroyVectorSequence ( REAL4VectorSequence * vecseq );


void LALCreateSequence(LALStatus *, REAL4Sequence **, UINT4);
void LALDestroySequence(LALStatus *, REAL4Sequence **);

void LALCreateVectorSequence(LALStatus *, REAL4VectorSequence **,
                             CreateVectorSequenceIn *);
void LALDestroyVectorSequence(LALStatus *, REAL4VectorSequence**);

void LALCreateArraySequence(LALStatus *, REAL4ArraySequence **,
                            CreateArraySequenceIn *);
void LALDestroyArraySequence(LALStatus *, REAL4ArraySequence **);
                       

/*

















  
  
*/

CHARVectorSequence * XLALCreateCHARVectorSequence ( UINT4 length, UINT4 veclen );
void XLALDestroyCHARVectorSequence ( CHARVectorSequence * vecseq );

void LALCHARCreateSequence ( LALStatus *status,
          CHARSequence   **sequence,
          UINT4);
          
void LALCHARDestroySequence ( LALStatus  *status,
          CHARSequence   **sequence);
          
void LALCHARCreateVectorSequence ( LALStatus *status,
          CHARVectorSequence **vectorSequence,
          CreateVectorSequenceIn *vSeqParams);
          
void LALCHARDestroyVectorSequence ( LALStatus *status,
          CHARVectorSequence **vectorSequence);
          



/*

















  
  
*/

INT2VectorSequence * XLALCreateINT2VectorSequence ( UINT4 length, UINT4 veclen );
void XLALDestroyINT2VectorSequence ( INT2VectorSequence * vecseq );

void LALI2CreateSequence ( LALStatus *status,
          INT2Sequence   **sequence,
          UINT4);
          
void LALI2DestroySequence ( LALStatus  *status,
          INT2Sequence   **sequence);
          
void LALI2CreateVectorSequence ( LALStatus *status,
          INT2VectorSequence **vectorSequence,
          CreateVectorSequenceIn *vSeqParams);
          
void LALI2DestroyVectorSequence ( LALStatus *status,
          INT2VectorSequence **vectorSequence);
          

/*













*/

          

void LALI2CreateArraySequence ( LALStatus *status,
          INT2ArraySequence **arraySequence,
          CreateArraySequenceIn *aSeqParams);
          
void LALI2DestroyArraySequence ( LALStatus *status,
          INT2ArraySequence **arraySeqence);
          



/*

















  
  
*/

INT4VectorSequence * XLALCreateINT4VectorSequence ( UINT4 length, UINT4 veclen );
void XLALDestroyINT4VectorSequence ( INT4VectorSequence * vecseq );

void LALI4CreateSequence ( LALStatus *status,
          INT4Sequence   **sequence,
          UINT4);
          
void LALI4DestroySequence ( LALStatus  *status,
          INT4Sequence   **sequence);
          
void LALI4CreateVectorSequence ( LALStatus *status,
          INT4VectorSequence **vectorSequence,
          CreateVectorSequenceIn *vSeqParams);
          
void LALI4DestroyVectorSequence ( LALStatus *status,
          INT4VectorSequence **vectorSequence);
          

/*













*/

          

void LALI4CreateArraySequence ( LALStatus *status,
          INT4ArraySequence **arraySequence,
          CreateArraySequenceIn *aSeqParams);
          
void LALI4DestroyArraySequence ( LALStatus *status,
          INT4ArraySequence **arraySeqence);
          



/*

















  
  
*/

INT8VectorSequence * XLALCreateINT8VectorSequence ( UINT4 length, UINT4 veclen );
void XLALDestroyINT8VectorSequence ( INT8VectorSequence * vecseq );

void LALI8CreateSequence ( LALStatus *status,
          INT8Sequence   **sequence,
          UINT4);
          
void LALI8DestroySequence ( LALStatus  *status,
          INT8Sequence   **sequence);
          
void LALI8CreateVectorSequence ( LALStatus *status,
          INT8VectorSequence **vectorSequence,
          CreateVectorSequenceIn *vSeqParams);
          
void LALI8DestroyVectorSequence ( LALStatus *status,
          INT8VectorSequence **vectorSequence);
          

/*













*/

          

void LALI8CreateArraySequence ( LALStatus *status,
          INT8ArraySequence **arraySequence,
          CreateArraySequenceIn *aSeqParams);
          
void LALI8DestroyArraySequence ( LALStatus *status,
          INT8ArraySequence **arraySeqence);
          



/*

















  
  
*/

UINT2VectorSequence * XLALCreateUINT2VectorSequence ( UINT4 length, UINT4 veclen );
void XLALDestroyUINT2VectorSequence ( UINT2VectorSequence * vecseq );

void LALU2CreateSequence ( LALStatus *status,
          UINT2Sequence   **sequence,
          UINT4);
          
void LALU2DestroySequence ( LALStatus  *status,
          UINT2Sequence   **sequence);
          
void LALU2CreateVectorSequence ( LALStatus *status,
          UINT2VectorSequence **vectorSequence,
          CreateVectorSequenceIn *vSeqParams);
          
void LALU2DestroyVectorSequence ( LALStatus *status,
          UINT2VectorSequence **vectorSequence);
          

/*













*/

          

void LALU2CreateArraySequence ( LALStatus *status,
          UINT2ArraySequence **arraySequence,
          CreateArraySequenceIn *aSeqParams);
          
void LALU2DestroyArraySequence ( LALStatus *status,
          UINT2ArraySequence **arraySeqence);
          



/*

















  
  
*/

UINT4VectorSequence * XLALCreateUINT4VectorSequence ( UINT4 length, UINT4 veclen );
void XLALDestroyUINT4VectorSequence ( UINT4VectorSequence * vecseq );

void LALU4CreateSequence ( LALStatus *status,
          UINT4Sequence   **sequence,
          UINT4);
          
void LALU4DestroySequence ( LALStatus  *status,
          UINT4Sequence   **sequence);
          
void LALU4CreateVectorSequence ( LALStatus *status,
          UINT4VectorSequence **vectorSequence,
          CreateVectorSequenceIn *vSeqParams);
          
void LALU4DestroyVectorSequence ( LALStatus *status,
          UINT4VectorSequence **vectorSequence);
          

/*













*/

          

void LALU4CreateArraySequence ( LALStatus *status,
          UINT4ArraySequence **arraySequence,
          CreateArraySequenceIn *aSeqParams);
          
void LALU4DestroyArraySequence ( LALStatus *status,
          UINT4ArraySequence **arraySeqence);
          



/*

















  
  
*/

UINT8VectorSequence * XLALCreateUINT8VectorSequence ( UINT4 length, UINT4 veclen );
void XLALDestroyUINT8VectorSequence ( UINT8VectorSequence * vecseq );

void LALU8CreateSequence ( LALStatus *status,
          UINT8Sequence   **sequence,
          UINT4);
          
void LALU8DestroySequence ( LALStatus  *status,
          UINT8Sequence   **sequence);
          
void LALU8CreateVectorSequence ( LALStatus *status,
          UINT8VectorSequence **vectorSequence,
          CreateVectorSequenceIn *vSeqParams);
          
void LALU8DestroyVectorSequence ( LALStatus *status,
          UINT8VectorSequence **vectorSequence);
          

/*













*/

          

void LALU8CreateArraySequence ( LALStatus *status,
          UINT8ArraySequence **arraySequence,
          CreateArraySequenceIn *aSeqParams);
          
void LALU8DestroyArraySequence ( LALStatus *status,
          UINT8ArraySequence **arraySeqence);
          



/*

















  
  
*/

REAL4VectorSequence * XLALCreateREAL4VectorSequence ( UINT4 length, UINT4 veclen );
void XLALDestroyREAL4VectorSequence ( REAL4VectorSequence * vecseq );

void LALSCreateSequence ( LALStatus *status,
          REAL4Sequence   **sequence,
          UINT4);
          
void LALSDestroySequence ( LALStatus  *status,
          REAL4Sequence   **sequence);
          
void LALSCreateVectorSequence ( LALStatus *status,
          REAL4VectorSequence **vectorSequence,
          CreateVectorSequenceIn *vSeqParams);
          
void LALSDestroyVectorSequence ( LALStatus *status,
          REAL4VectorSequence **vectorSequence);
          

/*













*/

          

void LALSCreateArraySequence ( LALStatus *status,
          REAL4ArraySequence **arraySequence,
          CreateArraySequenceIn *aSeqParams);
          
void LALSDestroyArraySequence ( LALStatus *status,
          REAL4ArraySequence **arraySeqence);
          



/*

















  
  
*/

REAL8VectorSequence * XLALCreateREAL8VectorSequence ( UINT4 length, UINT4 veclen );
void XLALDestroyREAL8VectorSequence ( REAL8VectorSequence * vecseq );

void LALDCreateSequence ( LALStatus *status,
          REAL8Sequence   **sequence,
          UINT4);
          
void LALDDestroySequence ( LALStatus  *status,
          REAL8Sequence   **sequence);
          
void LALDCreateVectorSequence ( LALStatus *status,
          REAL8VectorSequence **vectorSequence,
          CreateVectorSequenceIn *vSeqParams);
          
void LALDDestroyVectorSequence ( LALStatus *status,
          REAL8VectorSequence **vectorSequence);
          

/*













*/

          

void LALDCreateArraySequence ( LALStatus *status,
          REAL8ArraySequence **arraySequence,
          CreateArraySequenceIn *aSeqParams);
          
void LALDDestroyArraySequence ( LALStatus *status,
          REAL8ArraySequence **arraySeqence);
          



/*

















  
  
*/

COMPLEX8VectorSequence * XLALCreateCOMPLEX8VectorSequence ( UINT4 length, UINT4 veclen );
void XLALDestroyCOMPLEX8VectorSequence ( COMPLEX8VectorSequence * vecseq );

void LALCCreateSequence ( LALStatus *status,
          COMPLEX8Sequence   **sequence,
          UINT4);
          
void LALCDestroySequence ( LALStatus  *status,
          COMPLEX8Sequence   **sequence);
          
void LALCCreateVectorSequence ( LALStatus *status,
          COMPLEX8VectorSequence **vectorSequence,
          CreateVectorSequenceIn *vSeqParams);
          
void LALCDestroyVectorSequence ( LALStatus *status,
          COMPLEX8VectorSequence **vectorSequence);
          

/*













*/

          

void LALCCreateArraySequence ( LALStatus *status,
          COMPLEX8ArraySequence **arraySequence,
          CreateArraySequenceIn *aSeqParams);
          
void LALCDestroyArraySequence ( LALStatus *status,
          COMPLEX8ArraySequence **arraySeqence);
          



/*

















  
  
*/

COMPLEX16VectorSequence * XLALCreateCOMPLEX16VectorSequence ( UINT4 length, UINT4 veclen );
void XLALDestroyCOMPLEX16VectorSequence ( COMPLEX16VectorSequence * vecseq );

void LALZCreateSequence ( LALStatus *status,
          COMPLEX16Sequence   **sequence,
          UINT4);
          
void LALZDestroySequence ( LALStatus  *status,
          COMPLEX16Sequence   **sequence);
          
void LALZCreateVectorSequence ( LALStatus *status,
          COMPLEX16VectorSequence **vectorSequence,
          CreateVectorSequenceIn *vSeqParams);
          
void LALZDestroyVectorSequence ( LALStatus *status,
          COMPLEX16VectorSequence **vectorSequence);
          

/*













*/

          

void LALZCreateArraySequence ( LALStatus *status,
          COMPLEX16ArraySequence **arraySequence,
          CreateArraySequenceIn *aSeqParams);
          
void LALZDestroyArraySequence ( LALStatus *status,
          COMPLEX16ArraySequence **arraySeqence);
          



/* <lalLaTeX>
\newpage\input{VectorSequenceFactoriesTestC}
</lalLaTeX> */

/* <lalLaTeX>
\newpage\input{ArraySequenceFactoriesTestC}
</lalLaTeX> */

#ifdef  __cplusplus
}
#endif

#endif /* _SEQFACTORIES_H */

---