Index: /trunk/doc/pslib/ChangeLogSDRS.tex
===================================================================
--- /trunk/doc/pslib/ChangeLogSDRS.tex	(revision 4046)
+++ /trunk/doc/pslib/ChangeLogSDRS.tex	(revision 4047)
@@ -1,3 +1,3 @@
-%%% $Id: ChangeLogSDRS.tex,v 1.104 2005-05-27 00:38:08 eugene Exp $
+%%% $Id: ChangeLogSDRS.tex,v 1.105 2005-05-28 03:21:17 jhoblitt Exp $
 
 \subsection{Changes from version 00 to version 01}
@@ -622,3 +622,17 @@
 \item added the psVectorClipFitPoly* functions
 
-\end{itemize}
+\item SDRS API clean up and implementation re-synchronization
+  \begin{itemize}
+  \item rename psFinalize() $\rightarrow$ psLibCleanup()
+  \item change parameters expecting \code{__LINE__} to type \code{int}
+  \item change \code{int} $\rightarrow$ \code{size_t} where appropriate
+  \item change \code{psBool} $\rightarrow$ \code{bool}
+  \item add \code{const} to parameters where appropriate
+  \item remove \code{const} from parameters passed by value
+  \item change \code{void *} $\rightarrow$ \code{psPtr} where appropriate
+  \item change parameter names to be consistent with the current implementation
+  \item change parameter names to be more consistent between related functions
+  \item change parameter types to be more consistent with related data structures 
+  \item change \code{psF64} $\rightarrow$ \code{double} where appropriate
+  \end{itemize}
+\end{itemize}
Index: /trunk/doc/pslib/psLibSDRS.tex
===================================================================
--- /trunk/doc/pslib/psLibSDRS.tex	(revision 4046)
+++ /trunk/doc/pslib/psLibSDRS.tex	(revision 4047)
@@ -1,3 +1,3 @@
-%%% $Id: psLibSDRS.tex,v 1.235 2005-05-27 21:50:15 price Exp $
+%%% $Id: psLibSDRS.tex,v 1.236 2005-05-28 03:21:17 jhoblitt Exp $
 \documentclass[panstarrs,spec]{panstarrs}
 
@@ -221,8 +221,8 @@
 
 \begin{prototype}
-void psFinalize(void);
-\end{prototype}
-
-\code{psLibFinalize} shall free memory that was allocated by
+void psLibCleanup(void);
+\end{prototype}
+
+\code{psLibCleanup} shall free memory that was allocated by
 \code{psLibInit}, allowing a subsequent search for leaked memory.
 
@@ -422,7 +422,7 @@
 %
 \begin{prototype}
-void *psAlloc(size_t size);
-void *psRealloc(void *ptr, size_t size);
-void *psFree(void *ptr);
+psPtr psAlloc(size_t size);
+psPtr psRealloc(psPtr ptr, size_t size);
+void psFree(psPtr ptr);
 \end{prototype}
 %
@@ -434,7 +434,7 @@
 %
 \begin{prototype}
-void *p_psAlloc(size_t size, const char *file, int line);
-void *p_psRealloc(void *ptr, size_t size, const char *file, int line);
-void p_psFree(void *ptr, const char *file, int line);
+psPtr p_psAlloc(size_t size, const char *file, int lineno);
+psPtr p_psRealloc(psPtr ptr, size_t size, const char *file, int lineno);
+void p_psFree(psPtr ptr, const char *file, int lineno);
 \end{prototype}
 %
@@ -703,7 +703,7 @@
 %
 \begin{prototype}
-psReferenceCount psMemGetRefCounter(const void *vptr);
-void *psMemIncrRefCounter(const void *vptr);
-void *psMemDecrRefCounter(void *vptr);
+psReferenceCount psMemGetRefCounter(const psPtr ptr);
+psPtr psMemIncrRefCounter(const psPtr ptr);
+psPtr psMemDecrRefCounter(psPtr ptr);
 \end{prototype}
 %
@@ -1146,5 +1146,5 @@
 may be registered with the PSLib error handler using the function:
 \begin{prototype}
-void psErrorRegister(const psErrorDescription *errors, int nerror);
+void psErrorRegister(const psErrorDescription *errors, psS32 nerror);
 \end{prototype}
 where the errors are represented internally as follows:
@@ -1390,7 +1390,7 @@
 %
 \begin{prototype}
-psVector *psVectorAlloc(int nalloc, psElemType type);
-psVector *psVectorRealloc(psVector *vector, int nalloc);
-psVector *psVectorRecycle(psVector *vector, int nalloc, psElemType type);
+psVector *psVectorAlloc(psU32 nalloc, psElemType type);
+psVector *psVectorRealloc(psVector *vector, psU32 nalloc);
+psVector *psVectorRecycle(psVector *vector, psU32 nalloc, psElemType type);
 \end{prototype}
 %
@@ -1503,5 +1503,5 @@
 
 \begin{prototype}
-psImage *psImageAlloc (int width, int height, psElemType type);
+psImage *psImageAlloc(psU32 width, psU32 height, psElemType type);
 psImage* psImageRecycle(psImage* old, int numCols, int numRows, const psElemType type);
 \end{prototype}
@@ -1558,6 +1558,6 @@
 %
 \begin{prototype}
-psArray *psArrayAlloc(int nalloc);
-psArray *psArrayRealloc(const psArray *array, int nalloc);
+psArray *psArrayAlloc(psU32 nalloc);
+psArray *psArrayRealloc(psArray *array, psU32 nalloc);
 \end{prototype}
 %
@@ -1576,5 +1576,5 @@
 
 \begin{prototype}
-psArray *psArrayAdd(psArray *array, int delta, const void *value);
+psArray *psArrayAdd(psArray *array, psU32 delta, psPtr data);
 \end{prototype}
 
@@ -1586,5 +1586,5 @@
 
 \begin{prototype}
-psBool psArrayRemove(psArray *array, const psPtr value);
+bool psArrayRemove(psArray *array, const psPtr data);
 \end{prototype}
 
@@ -1595,6 +1595,6 @@
 
 \begin{prototype}
-psBool psArraySet(psArray* in, psU32 position, const void* value);
-void* psArrayGet(const psArray* in, psU32 position);
+bool psArraySet(psArray *array, psU32 position, psPtr data);
+psPtr psArrayGet(const psArray *array, psU32 position);
 \end{prototype}
 
@@ -1855,5 +1855,5 @@
 A hash table is created with the following function:
 \begin{prototype}
-psHash *psHashAlloc(int nbuckets);
+psHash *psHashAlloc(psS32 nbuckets);
 \end{prototype}
 which allocates the space for the hash table, creating and
@@ -1864,5 +1864,5 @@
 A data item may be added to the hash table with the function:
 \begin{prototype}
-bool psHashAdd(psHash *table, const char *key, const void *data);
+bool psHashAdd(psHash *table, const char *key, psPtr data);
 \end{prototype}
 In this function, the value of the string \code{key} is used to
@@ -1894,5 +1894,5 @@
 
 \begin{prototype}
-psArray *psHashToArray(const psHash *hash);
+psArray *psHashToArray(const psHash *table);
 \end{prototype}
 This function places the data in a \code{psHash} into a \code{psArray}
@@ -2054,5 +2054,5 @@
 We also require the corresponding constructor and destructor:
 \begin{prototype}
-psBitSet *psBitSetAlloc(int n);
+psBitSet *psBitSetAlloc(psS32 n);
 \end{prototype}
 where \code{n} is the requested number of bits.
@@ -2068,10 +2068,10 @@
 
 \begin{prototype}
-psBitSet *psBitSetSet(psBitSet *myBits, int bit);
-psBitSet* psBitSetClear(psBitSet* inBits, int bit);
-psBitSet *psBitSetOp(psBitSet *outBits, const psBitSet *inBits1, const char *operator, const psBitSet *inBits2);
-psBitSet *psBitSetNot(psBitSet *out, const psBitSet *in);
-bool psBitSetTest(const psBitSet *checkBits, int bit);
-char *psBitSetToString(const pBitSet* bits);
+psBitSet *psBitSetSet(psBitSet *bitSet, psS32 bit);
+psBitSet* psBitSetClear(psBitSet *bitSet, psS32 bit);
+psBitSet *psBitSetOp(psBitSet *outBitSet, const psBitSet *inBitSet1, const char *operator, const psBitSet *inBitSet2);
+psBitSet *psBitSetNot(psBitSet *outBitSet, const psBitSet *inBitSet);
+bool psBitSetTest(const psBitSet *bitSet, psS32 bit);
+char *psBitSetToString(const psBitSet* bitSet);
 \end{prototype}
 
@@ -2112,5 +2112,5 @@
 
 \begin{prototype}
-psVector *psVectorSort(psVector *out, const psVector *in);
+psVector *psVectorSort(psVector *outVector, const psVector *inVector);
 \end{prototype}
 
@@ -2126,5 +2126,5 @@
 
 \begin{prototype}
-psVector *psVectorSortIndex(psVector *out; const psVector *in);
+psVector *psVectorSortIndex(psVector *outVector, const psVector *inVector);
 \end{prototype}
 
@@ -3387,6 +3387,6 @@
 
 \begin{prototype}
-psType *psBinaryOp(void *out, const void *in1, const char *op, const void *in2);
-psType *psUnaryOp(void *out, const void *in, const char *op);
+psType *psBinaryOp(psPtr out, const psPtr in1, const char *op, const psPtr in2);
+psType *psUnaryOp(psPtr out, const psPtr in, const char *op);
 \end{prototype}
 These functions determine the type of the operands on the basis of
@@ -3550,6 +3550,6 @@
 should match.
 \begin{prototype}
-psVector *psMatrixToVector(psVector *out, const psImage *in);
-psImage *psVectorToMatrix(psImage *out, const psVector *in);
+psVector *psMatrixToVector(psVector *outVector, const psImage *inImage);
+psImage *psVectorToMatrix(psImage *outImage, const psVector *inVector);
 \end{prototype}
 
@@ -4005,5 +4005,5 @@
 psMetadataItem* psMetadataItemAllocF64(const char* name, const char* comment, psF64 value);
 psMetadataItem* psMetadataItemAllocS32(const char* name, const char* comment, psS32 value);
-psMetadataItem* psMetadataItemAllocBool(const char* name, const char* comment, psBool value);
+psMetadataItem* psMetadataItemAllocBool(const char* name, const char* comment, bool value);
 \end{prototype}
 
@@ -4149,22 +4149,22 @@
 are specified:
 \begin{prototype}
-psBool psMetadataAddS32(psMetadata* md, psS32 location, const char* name, const char* comment, psS32 value);
-psBool psMetadataAddF32(psMetadata* md, psS32 location, const char* name, const char* comment, psF32 value);
-psBool psMetadataAddF64(psMetadata* md, psS32 location, const char* name, const char* comment, psF64 value);
-psBool psMetadataAddList(psMetadata* md, psS32 location, const char* name, const char* comment,
+bool psMetadataAddS32(psMetadata* md, psS32 location, const char* name, const char* comment, psS32 value);
+bool psMetadataAddF32(psMetadata* md, psS32 location, const char* name, const char* comment, psF32 value);
+bool psMetadataAddF64(psMetadata* md, psS32 location, const char* name, const char* comment, psF64 value);
+bool psMetadataAddList(psMetadata* md, psS32 location, const char* name, const char* comment,
                          const psList* value);
-psBool psMetadataAddStr(psMetadata* md, psS32 location, const char* name, const char* comment,
+bool psMetadataAddStr(psMetadata* md, psS32 location, const char* name, const char* comment,
                         const char* value);
-psBool psMetadataAddVector(psMetadata* md, psS32 location, const char* name, const char* comment,
+bool psMetadataAddVector(psMetadata* md, psS32 location, const char* name, const char* comment,
                            const psVector* value);
-psBool psMetadataAddImage(psMetadata* md, psS32 location, const char* name, const char* comment,
+bool psMetadataAddImage(psMetadata* md, psS32 location, const char* name, const char* comment,
                           const psImage* value);
-psBool psMetadataAddHash(psMetadata* md, psS32 location, const char* name, const char* comment,
+bool psMetadataAddHash(psMetadata* md, psS32 location, const char* name, const char* comment,
                          const psHash* value);
-psBool psMetadataAddLookupTable(psMetadata* md, psS32 location, const char* name, const char* comment,
+bool psMetadataAddLookupTable(psMetadata* md, psS32 location, const char* name, const char* comment,
                                 const psLookupTable* value);
-psBool psMetadataAddUnknown(psMetadata* md, psS32 location, const char* name, const char* comment,
+bool psMetadataAddUnknown(psMetadata* md, psS32 location, const char* name, const char* comment,
                             const psPtr value);
-psBool psMetadataAddMetadata(psMetadata* md, psS32 location, const char* name, const char* comment,
+bool psMetadataAddMetadata(psMetadata* md, psS32 location, const char* name, const char* comment,
                              const psMetadata* value);
 \end{prototype}
@@ -4518,5 +4518,5 @@
 into a complete \code{psXMLDoc} (also in memory), and vice versa:
 \begin{prototype}
-psXMLDoc *psXMLParseMemory(const char *buffer, const int size);
+psXMLDoc *psXMLParseMemory(const char *buffer, int size);
 int psXMLDocToMemory(const psXMLDoc *doc, char *buffer);
 \end{prototype}
@@ -4648,6 +4648,6 @@
 
 \begin{prototype}
-    psArray *psDBSelectColumn(psDB *dbh, const char *tableName, const char *col, const psU64 limit);
-    psVector *psDBSelectColumnNum(psDB *dbh, const char *tableName, const char *col, psMetadataType type, const psU64 limit);
+    psArray *psDBSelectColumn(psDB *dbh, const char *tableName, const char *col, psU64 limit);
+    psVector *psDBSelectColumnNum(psDB *dbh, const char *tableName, const char *col, psElemType type, psU64 limit);
 \end{prototype}
 
@@ -4660,5 +4660,5 @@
 
 \begin{prototype}
-    psArray *psDBSelectRows(psDB *dbh, const char *tableName, psMetadata *where, const psU64 limit);
+    psArray *psDBSelectRows(psDB *dbh, const char *tableName, psMetadata *where, psU64 limit);
 \end{prototype}
 
@@ -4751,5 +4751,5 @@
 
 \begin{prototype}
-bool psFitsMoveExtName(psFits *fits, const char *extname);
+bool psFitsMoveExtName(const psFits *fits, const char *extname);
 \end{prototype}
 
@@ -4759,5 +4759,5 @@
 
 \begin{prototype}
-bool psFitsMoveExtNum(psFits* fits, int extnum, bool relative);
+bool psFitsMoveExtNum(const psFits* fits, int extnum, bool relative);
 \end{prototype}
 
@@ -4768,5 +4768,5 @@
 
 \begin{prototype}
-int psFitsGetExtNum(psFits* fits);
+int psFitsGetExtNum(const psFits* fits);
 \end{prototype}
 
@@ -4774,5 +4774,5 @@
 
 \begin{prototype}
-int psFitsGetSize(psFits* fits);
+int psFitsGetSize(const psFits* fits);
 \end{prototype}
 
@@ -4780,5 +4780,5 @@
 
 \begin{prototype}
-psFitsType psFitsGetExtType(psFits* fits);
+psFitsType psFitsGetExtType(const psFits* fits);
 \end{prototype}
 
@@ -4786,5 +4786,5 @@
 
 \begin{prototype}
-char *psFitsGetExtName(psFits* fits);
+char *psFitsGetExtName(const psFits* fits);
 bool psFitsSetExtName(psFits* fits, const char* name);
 \end{prototype}
@@ -4799,5 +4799,5 @@
 
 \begin{prototype}
-psMetadata *psFitsReadHeader(psMetadata *out, psFits *fits);
+psMetadata *psFitsReadHeader(psMetadata *out, const psFits *fits);
 \end{prototype}
 Read header data into a \code{psMetadata} structure.  The data is read
@@ -4806,5 +4806,5 @@
 
 \begin{prototype}
-psMetadata *psFitsReadHeaderSet (psFits *fits);
+psMetadata *psFitsReadHeaderSet(const psFits *fits);
 \end{prototype}
 Load a complete set of headers from the \code{psFits} file pointer.
@@ -4819,5 +4819,5 @@
 
 \begin{prototype}
-bool psFitsWriteHeader(psMetadata *output, psFits *fits);
+bool psFitsWriteHeader(const psMetadata *output, psFits *fits);
 \end{prototype}
 Write metadata into the header of a FITS image file.  The header is
@@ -4827,5 +4827,5 @@
 
 \begin{prototype}
-psImage *psFitsReadImage(psImage *output, psFits *fits, psRegion region, int z);
+psImage *psFitsReadImage(psImage *out, const psFits *fits, const psRegion region, int z);
 \end{prototype}
 Read an image or subimage from the \code{psFits} file pointer.  This
@@ -4877,5 +4877,5 @@
 
 \begin{prototype}
-psMetadata *psFitsReadTableRow (psFits *fits, int row);
+psMetadata *psFitsReadTableRow(const psFits *fits, int row);
 \end{prototype}
 This function reads a single row of the table in the extension pointed
@@ -4891,5 +4891,5 @@
 
 \begin{prototype}
-void *psFitsReadTableRowRaw (int *nBytes, psFits *fits, int row);
+void *psFitsReadTableRowRaw(const int *nBytes, const psFits *fits, int row);
 \end{prototype}
 This function reads a single row of the table in the extension pointed
@@ -4904,5 +4904,5 @@
 
 \begin{prototype}
-psArray *psFitsReadTableColumn (psFits *fits, const char *colname);
+psArray *psFitsReadTableColumn(const psFits *fits, const char *colname);
 \end{prototype}
 This function reads a single column of the table in the extension
@@ -4913,5 +4913,5 @@
 
 \begin{prototype}
-psVector *psFitsReadTableColumnNum (psFits *fits, const char *colname);
+psVector *psFitsReadTableColumnNum(const psFits *fits, const char *colname);
 \end{prototype}
 This function reads a single column of the table in the extension
@@ -4923,5 +4923,5 @@
 
 \begin{prototype}
-psArray *psFitsReadTableRaw (int *nBytes, psFits *fits);
+psArray *psFitsReadTableRaw(int *nBytes, const psFits *fits);
 \end{prototype}
 This function reads the entire data block from a table into the a
@@ -5093,6 +5093,6 @@
 
 \begin{prototype}
-psF64 psTimeToJD(const psTime *time);
-psF64 psTimeToMJD(const psTime *time);
+double psTimeToJD(const psTime *time);
+double psTimeToMJD(const psTime *time);
 char *psTimeToISO(const psTime *time);
 timeval *psTimeToTimeval(const psTime *time);
@@ -5109,6 +5109,6 @@
 
 \begin{prototype}
-psTime *psTimeFromJD(psF64 input);
-psTime *psTimeFromMJD(psF64 input);
+psTime *psTimeFromJD(double input);
+psTime *psTimeFromMJD(double input);
 psTime *psTimeFromISO(const char *input, psTimeType timeSystem);
 psTime *psTimeFromTimeval(const timeval *input);