IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 4047


Ignore:
Timestamp:
May 27, 2005, 5:21:17 PM (21 years ago)
Author:
jhoblitt
Message:

SDRS API clean up and implementation re-synchronization

  • rename psFinalize() -> psLibCleanup()
  • change parameters expecting LINE to type int
  • change int -> size_t where appropriate
  • change psBool -> bool
  • add const to parameters where appropriate
  • remove const from parameters passed by value
  • change void * -> psPtr where appropriate
  • change parameter names to be consistent with the current implementation
  • change parameter names to be more consistent between related functions
  • change parameter types to be more consistent with related data structures
  • change psF64 -> double where appropriate
Location:
trunk/doc/pslib
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/doc/pslib/ChangeLogSDRS.tex

    r4040 r4047  
    1 %%% $Id: ChangeLogSDRS.tex,v 1.104 2005-05-27 00:38:08 eugene Exp $
     1%%% $Id: ChangeLogSDRS.tex,v 1.105 2005-05-28 03:21:17 jhoblitt Exp $
    22
    33\subsection{Changes from version 00 to version 01}
    … …  
    622622\item added the psVectorClipFitPoly* functions
    623623
    624 \end{itemize}
     624\item SDRS API clean up and implementation re-synchronization
     625  \begin{itemize}
     626  \item rename psFinalize() $\rightarrow$ psLibCleanup()
     627  \item change parameters expecting \code{__LINE__} to type \code{int}
     628  \item change \code{int} $\rightarrow$ \code{size_t} where appropriate
     629  \item change \code{psBool} $\rightarrow$ \code{bool}
     630  \item add \code{const} to parameters where appropriate
     631  \item remove \code{const} from parameters passed by value
     632  \item change \code{void *} $\rightarrow$ \code{psPtr} where appropriate
     633  \item change parameter names to be consistent with the current implementation
     634  \item change parameter names to be more consistent between related functions
     635  \item change parameter types to be more consistent with related data structures
     636  \item change \code{psF64} $\rightarrow$ \code{double} where appropriate
     637  \end{itemize}
     638\end{itemize}

  • trunk/doc/pslib/psLibSDRS.tex

    r4042 r4047  
    1 %%% $Id: psLibSDRS.tex,v 1.235 2005-05-27 21:50:15 price Exp $
     1%%% $Id: psLibSDRS.tex,v 1.236 2005-05-28 03:21:17 jhoblitt Exp $
    22\documentclass[panstarrs,spec]{panstarrs}
    33
    … …  
    221221
    222222\begin{prototype}
    223 void psFinalize(void);
    224 \end{prototype}
    225 
    226 \code{psLibFinalize} shall free memory that was allocated by
     223void psLibCleanup(void);
     224\end{prototype}
     225
     226\code{psLibCleanup} shall free memory that was allocated by
    227227\code{psLibInit}, allowing a subsequent search for leaked memory.
    228228
    … …  
    422422%
    423423\begin{prototype}
    424 void *psAlloc(size_t size);
    425 void *psRealloc(void *ptr, size_t size);
    426 void *psFree(void *ptr);
     424psPtr psAlloc(size_t size);
     425psPtr psRealloc(psPtr ptr, size_t size);
     426void psFree(psPtr ptr);
    427427\end{prototype}
    428428%
    … …  
    434434%
    435435\begin{prototype}
    436 void *p_psAlloc(size_t size, const char *file, int line);
    437 void *p_psRealloc(void *ptr, size_t size, const char *file, int line);
    438 void p_psFree(void *ptr, const char *file, int line);
     436psPtr p_psAlloc(size_t size, const char *file, int lineno);
     437psPtr p_psRealloc(psPtr ptr, size_t size, const char *file, int lineno);
     438void p_psFree(psPtr ptr, const char *file, int lineno);
    439439\end{prototype}
    440440%
    … …  
    703703%
    704704\begin{prototype}
    705 psReferenceCount psMemGetRefCounter(const void *vptr);
    706 void *psMemIncrRefCounter(const void *vptr);
    707 void *psMemDecrRefCounter(void *vptr);
     705psReferenceCount psMemGetRefCounter(const psPtr ptr);
     706psPtr psMemIncrRefCounter(const psPtr ptr);
     707psPtr psMemDecrRefCounter(psPtr ptr);
    708708\end{prototype}
    709709%
    … …  
    11461146may be registered with the PSLib error handler using the function:
    11471147\begin{prototype}
    1148 void psErrorRegister(const psErrorDescription *errors, int nerror);
     1148void psErrorRegister(const psErrorDescription *errors, psS32 nerror);
    11491149\end{prototype}
    11501150where the errors are represented internally as follows:
    … …  
    13901390%
    13911391\begin{prototype}
    1392 psVector *psVectorAlloc(int nalloc, psElemType type);
    1393 psVector *psVectorRealloc(psVector *vector, int nalloc);
    1394 psVector *psVectorRecycle(psVector *vector, int nalloc, psElemType type);
     1392psVector *psVectorAlloc(psU32 nalloc, psElemType type);
     1393psVector *psVectorRealloc(psVector *vector, psU32 nalloc);
     1394psVector *psVectorRecycle(psVector *vector, psU32 nalloc, psElemType type);
    13951395\end{prototype}
    13961396%
    … …  
    15031503
    15041504\begin{prototype}
    1505 psImage *psImageAlloc (int width, int height, psElemType type);
     1505psImage *psImageAlloc(psU32 width, psU32 height, psElemType type);
    15061506psImage* psImageRecycle(psImage* old, int numCols, int numRows, const psElemType type);
    15071507\end{prototype}
    … …  
    15581558%
    15591559\begin{prototype}
    1560 psArray *psArrayAlloc(int nalloc);
    1561 psArray *psArrayRealloc(const psArray *array, int nalloc);
     1560psArray *psArrayAlloc(psU32 nalloc);
     1561psArray *psArrayRealloc(psArray *array, psU32 nalloc);
    15621562\end{prototype}
    15631563%
    … …  
    15761576
    15771577\begin{prototype}
    1578 psArray *psArrayAdd(psArray *array, int delta, const void *value);
     1578psArray *psArrayAdd(psArray *array, psU32 delta, psPtr data);
    15791579\end{prototype}
    15801580
    … …  
    15861586
    15871587\begin{prototype}
    1588 psBool psArrayRemove(psArray *array, const psPtr value);
     1588bool psArrayRemove(psArray *array, const psPtr data);
    15891589\end{prototype}
    15901590
    … …  
    15951595
    15961596\begin{prototype}
    1597 psBool psArraySet(psArray* in, psU32 position, const void* value);
    1598 void* psArrayGet(const psArray* in, psU32 position);
     1597bool psArraySet(psArray *array, psU32 position, psPtr data);
     1598psPtr psArrayGet(const psArray *array, psU32 position);
    15991599\end{prototype}
    16001600
    … …  
    18551855A hash table is created with the following function:
    18561856\begin{prototype}
    1857 psHash *psHashAlloc(int nbuckets);
     1857psHash *psHashAlloc(psS32 nbuckets);
    18581858\end{prototype}
    18591859which allocates the space for the hash table, creating and
    … …  
    18641864A data item may be added to the hash table with the function:
    18651865\begin{prototype}
    1866 bool psHashAdd(psHash *table, const char *key, const void *data);
     1866bool psHashAdd(psHash *table, const char *key, psPtr data);
    18671867\end{prototype}
    18681868In this function, the value of the string \code{key} is used to
    … …  
    18941894
    18951895\begin{prototype}
    1896 psArray *psHashToArray(const psHash *hash);
     1896psArray *psHashToArray(const psHash *table);
    18971897\end{prototype}
    18981898This function places the data in a \code{psHash} into a \code{psArray}
    … …  
    20542054We also require the corresponding constructor and destructor:
    20552055\begin{prototype}
    2056 psBitSet *psBitSetAlloc(int n);
     2056psBitSet *psBitSetAlloc(psS32 n);
    20572057\end{prototype}
    20582058where \code{n} is the requested number of bits.
    … …  
    20682068
    20692069\begin{prototype}
    2070 psBitSet *psBitSetSet(psBitSet *myBits, int bit);
    2071 psBitSet* psBitSetClear(psBitSet* inBits, int bit);
    2072 psBitSet *psBitSetOp(psBitSet *outBits, const psBitSet *inBits1, const char *operator, const psBitSet *inBits2);
    2073 psBitSet *psBitSetNot(psBitSet *out, const psBitSet *in);
    2074 bool psBitSetTest(const psBitSet *checkBits, int bit);
    2075 char *psBitSetToString(const pBitSet* bits);
     2070psBitSet *psBitSetSet(psBitSet *bitSet, psS32 bit);
     2071psBitSet* psBitSetClear(psBitSet *bitSet, psS32 bit);
     2072psBitSet *psBitSetOp(psBitSet *outBitSet, const psBitSet *inBitSet1, const char *operator, const psBitSet *inBitSet2);
     2073psBitSet *psBitSetNot(psBitSet *outBitSet, const psBitSet *inBitSet);
     2074bool psBitSetTest(const psBitSet *bitSet, psS32 bit);
     2075char *psBitSetToString(const psBitSet* bitSet);
    20762076\end{prototype}
    20772077
    … …  
    21122112
    21132113\begin{prototype}
    2114 psVector *psVectorSort(psVector *out, const psVector *in);
     2114psVector *psVectorSort(psVector *outVector, const psVector *inVector);
    21152115\end{prototype}
    21162116
    … …  
    21262126
    21272127\begin{prototype}
    2128 psVector *psVectorSortIndex(psVector *out; const psVector *in);
     2128psVector *psVectorSortIndex(psVector *outVector, const psVector *inVector);
    21292129\end{prototype}
    21302130
    … …  
    33873387
    33883388\begin{prototype}
    3389 psType *psBinaryOp(void *out, const void *in1, const char *op, const void *in2);
    3390 psType *psUnaryOp(void *out, const void *in, const char *op);
     3389psType *psBinaryOp(psPtr out, const psPtr in1, const char *op, const psPtr in2);
     3390psType *psUnaryOp(psPtr out, const psPtr in, const char *op);
    33913391\end{prototype}
    33923392These functions determine the type of the operands on the basis of
    … …  
    35503550should match.
    35513551\begin{prototype}
    3552 psVector *psMatrixToVector(psVector *out, const psImage *in);
    3553 psImage *psVectorToMatrix(psImage *out, const psVector *in);
     3552psVector *psMatrixToVector(psVector *outVector, const psImage *inImage);
     3553psImage *psVectorToMatrix(psImage *outImage, const psVector *inVector);
    35543554\end{prototype}
    35553555
    … …  
    40054005psMetadataItem* psMetadataItemAllocF64(const char* name, const char* comment, psF64 value);
    40064006psMetadataItem* psMetadataItemAllocS32(const char* name, const char* comment, psS32 value);
    4007 psMetadataItem* psMetadataItemAllocBool(const char* name, const char* comment, psBool value);
     4007psMetadataItem* psMetadataItemAllocBool(const char* name, const char* comment, bool value);
    40084008\end{prototype}
    40094009
    … …  
    41494149are specified:
    41504150\begin{prototype}
    4151 psBool psMetadataAddS32(psMetadata* md, psS32 location, const char* name, const char* comment, psS32 value);
    4152 psBool psMetadataAddF32(psMetadata* md, psS32 location, const char* name, const char* comment, psF32 value);
    4153 psBool psMetadataAddF64(psMetadata* md, psS32 location, const char* name, const char* comment, psF64 value);
    4154 psBool psMetadataAddList(psMetadata* md, psS32 location, const char* name, const char* comment,
     4151bool psMetadataAddS32(psMetadata* md, psS32 location, const char* name, const char* comment, psS32 value);
     4152bool psMetadataAddF32(psMetadata* md, psS32 location, const char* name, const char* comment, psF32 value);
     4153bool psMetadataAddF64(psMetadata* md, psS32 location, const char* name, const char* comment, psF64 value);
     4154bool psMetadataAddList(psMetadata* md, psS32 location, const char* name, const char* comment,
    41554155                         const psList* value);
    4156 psBool psMetadataAddStr(psMetadata* md, psS32 location, const char* name, const char* comment,
     4156bool psMetadataAddStr(psMetadata* md, psS32 location, const char* name, const char* comment,
    41574157                        const char* value);
    4158 psBool psMetadataAddVector(psMetadata* md, psS32 location, const char* name, const char* comment,
     4158bool psMetadataAddVector(psMetadata* md, psS32 location, const char* name, const char* comment,
    41594159                           const psVector* value);
    4160 psBool psMetadataAddImage(psMetadata* md, psS32 location, const char* name, const char* comment,
     4160bool psMetadataAddImage(psMetadata* md, psS32 location, const char* name, const char* comment,
    41614161                          const psImage* value);
    4162 psBool psMetadataAddHash(psMetadata* md, psS32 location, const char* name, const char* comment,
     4162bool psMetadataAddHash(psMetadata* md, psS32 location, const char* name, const char* comment,
    41634163                         const psHash* value);
    4164 psBool psMetadataAddLookupTable(psMetadata* md, psS32 location, const char* name, const char* comment,
     4164bool psMetadataAddLookupTable(psMetadata* md, psS32 location, const char* name, const char* comment,
    41654165                                const psLookupTable* value);
    4166 psBool psMetadataAddUnknown(psMetadata* md, psS32 location, const char* name, const char* comment,
     4166bool psMetadataAddUnknown(psMetadata* md, psS32 location, const char* name, const char* comment,
    41674167                            const psPtr value);
    4168 psBool psMetadataAddMetadata(psMetadata* md, psS32 location, const char* name, const char* comment,
     4168bool psMetadataAddMetadata(psMetadata* md, psS32 location, const char* name, const char* comment,
    41694169                             const psMetadata* value);
    41704170\end{prototype}
    … …  
    45184518into a complete \code{psXMLDoc} (also in memory), and vice versa:
    45194519\begin{prototype}
    4520 psXMLDoc *psXMLParseMemory(const char *buffer, const int size);
     4520psXMLDoc *psXMLParseMemory(const char *buffer, int size);
    45214521int psXMLDocToMemory(const psXMLDoc *doc, char *buffer);
    45224522\end{prototype}
    … …  
    46484648
    46494649\begin{prototype}
    4650     psArray *psDBSelectColumn(psDB *dbh, const char *tableName, const char *col, const psU64 limit);
    4651     psVector *psDBSelectColumnNum(psDB *dbh, const char *tableName, const char *col, psMetadataType type, const psU64 limit);
     4650    psArray *psDBSelectColumn(psDB *dbh, const char *tableName, const char *col, psU64 limit);
     4651    psVector *psDBSelectColumnNum(psDB *dbh, const char *tableName, const char *col, psElemType type, psU64 limit);
    46524652\end{prototype}
    46534653
    … …  
    46604660
    46614661\begin{prototype}
    4662     psArray *psDBSelectRows(psDB *dbh, const char *tableName, psMetadata *where, const psU64 limit);
     4662    psArray *psDBSelectRows(psDB *dbh, const char *tableName, psMetadata *where, psU64 limit);
    46634663\end{prototype}
    46644664
    … …  
    47514751
    47524752\begin{prototype}
    4753 bool psFitsMoveExtName(psFits *fits, const char *extname);
     4753bool psFitsMoveExtName(const psFits *fits, const char *extname);
    47544754\end{prototype}
    47554755
    … …  
    47594759
    47604760\begin{prototype}
    4761 bool psFitsMoveExtNum(psFits* fits, int extnum, bool relative);
     4761bool psFitsMoveExtNum(const psFits* fits, int extnum, bool relative);
    47624762\end{prototype}
    47634763
    … …  
    47684768
    47694769\begin{prototype}
    4770 int psFitsGetExtNum(psFits* fits);
     4770int psFitsGetExtNum(const psFits* fits);
    47714771\end{prototype}
    47724772
    … …  
    47744774
    47754775\begin{prototype}
    4776 int psFitsGetSize(psFits* fits);
     4776int psFitsGetSize(const psFits* fits);
    47774777\end{prototype}
    47784778
    … …  
    47804780
    47814781\begin{prototype}
    4782 psFitsType psFitsGetExtType(psFits* fits);
     4782psFitsType psFitsGetExtType(const psFits* fits);
    47834783\end{prototype}
    47844784
    … …  
    47864786
    47874787\begin{prototype}
    4788 char *psFitsGetExtName(psFits* fits);
     4788char *psFitsGetExtName(const psFits* fits);
    47894789bool psFitsSetExtName(psFits* fits, const char* name);
    47904790\end{prototype}
    … …  
    47994799
    48004800\begin{prototype}
    4801 psMetadata *psFitsReadHeader(psMetadata *out, psFits *fits);
     4801psMetadata *psFitsReadHeader(psMetadata *out, const psFits *fits);
    48024802\end{prototype}
    48034803Read header data into a \code{psMetadata} structure.  The data is read
    … …  
    48064806
    48074807\begin{prototype}
    4808 psMetadata *psFitsReadHeaderSet (psFits *fits);
     4808psMetadata *psFitsReadHeaderSet(const psFits *fits);
    48094809\end{prototype}
    48104810Load a complete set of headers from the \code{psFits} file pointer.
    … …  
    48194819
    48204820\begin{prototype}
    4821 bool psFitsWriteHeader(psMetadata *output, psFits *fits);
     4821bool psFitsWriteHeader(const psMetadata *output, psFits *fits);
    48224822\end{prototype}
    48234823Write metadata into the header of a FITS image file.  The header is
    … …  
    48274827
    48284828\begin{prototype}
    4829 psImage *psFitsReadImage(psImage *output, psFits *fits, psRegion region, int z);
     4829psImage *psFitsReadImage(psImage *out, const psFits *fits, const psRegion region, int z);
    48304830\end{prototype}
    48314831Read an image or subimage from the \code{psFits} file pointer.  This
    … …  
    48774877
    48784878\begin{prototype}
    4879 psMetadata *psFitsReadTableRow (psFits *fits, int row);
     4879psMetadata *psFitsReadTableRow(const psFits *fits, int row);
    48804880\end{prototype}
    48814881This function reads a single row of the table in the extension pointed
    … …  
    48914891
    48924892\begin{prototype}
    4893 void *psFitsReadTableRowRaw (int *nBytes, psFits *fits, int row);
     4893void *psFitsReadTableRowRaw(const int *nBytes, const psFits *fits, int row);
    48944894\end{prototype}
    48954895This function reads a single row of the table in the extension pointed
    … …  
    49044904
    49054905\begin{prototype}
    4906 psArray *psFitsReadTableColumn (psFits *fits, const char *colname);
     4906psArray *psFitsReadTableColumn(const psFits *fits, const char *colname);
    49074907\end{prototype}
    49084908This function reads a single column of the table in the extension
    … …  
    49134913
    49144914\begin{prototype}
    4915 psVector *psFitsReadTableColumnNum (psFits *fits, const char *colname);
     4915psVector *psFitsReadTableColumnNum(const psFits *fits, const char *colname);
    49164916\end{prototype}
    49174917This function reads a single column of the table in the extension
    … …  
    49234923
    49244924\begin{prototype}
    4925 psArray *psFitsReadTableRaw (int *nBytes, psFits *fits);
     4925psArray *psFitsReadTableRaw(int *nBytes, const psFits *fits);
    49264926\end{prototype}
    49274927This function reads the entire data block from a table into the a
    … …  
    50935093
    50945094\begin{prototype}
    5095 psF64 psTimeToJD(const psTime *time);
    5096 psF64 psTimeToMJD(const psTime *time);
     5095double psTimeToJD(const psTime *time);
     5096double psTimeToMJD(const psTime *time);
    50975097char *psTimeToISO(const psTime *time);
    50985098timeval *psTimeToTimeval(const psTime *time);
    … …  
    51095109
    51105110\begin{prototype}
    5111 psTime *psTimeFromJD(psF64 input);
    5112 psTime *psTimeFromMJD(psF64 input);
     5111psTime *psTimeFromJD(double input);
     5112psTime *psTimeFromMJD(double input);
    51135113psTime *psTimeFromISO(const char *input, psTimeType timeSystem);
    51145114psTime *psTimeFromTimeval(const timeval *input);
Note: See TracChangeset for help on using the changeset viewer.