IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
May 31, 2005, 3:33:39 PM (21 years ago)
Author:
jhoblitt
Message:

continuing SDRS API clean up and implementation re-synchronization
function/parameter/datatype renames

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/doc/pslib/psLibSDRS.tex

    r4057 r4061  
    1 %%% $Id: psLibSDRS.tex,v 1.238 2005-05-31 21:55:39 jhoblitt Exp $
     1%%% $Id: psLibSDRS.tex,v 1.239 2005-06-01 01:33:39 jhoblitt Exp $
    22\documentclass[panstarrs,spec]{panstarrs}
    33
    … …  
    335335    psFreeFcn freeFcn;                  ///< deallocator.  If NULL, use generic deallocation.
    336336    size_t  userMemorySize;             ///< the size of the user-portion of the memory block
    337     const psMemoryId id;                ///< a unique ID for this allocation
     337    const psMemId id;                   ///< a unique ID for this allocation
    338338    const char* file;                   ///< set from __FILE__ in e.g. p_psAlloc
    339     const int lineno;                   ///< set from __LINE__ in e.g. p_psAlloc
     339    const unsigned int lineno;          ///< set from __LINE__ in e.g. p_psAlloc
    340340    pthread_mutex_t   refCounterMutex;  ///< mutex to ensure exclusive access to reference counter
    341341    psReferenceCount refCounter;        ///< how many times pointer is referenced
    … …  
    345345
    346346typedef void (*psFreeFcn)(void* ptr);
    347 typedef unsigned long psMemoryId;
     347typedef unsigned long psMemId;
    348348typedef unsigned long psReferenceCount;
    349349\end{datatype}
    … …  
    434434%
    435435\begin{prototype}
    436 psPtr p_psAlloc(size_t size, const char *file, int lineno);
    437 psPtr p_psRealloc(psPtr ptr, size_t size, const char *file, int lineno);
    438 void p_psFree(psPtr ptr, const char *file, int lineno);
     436psPtr p_psAlloc(size_t size, const char *filename, unsigned int lineno);
     437psPtr p_psRealloc(psPtr ptr, size_t size, const char *filename, unsigned int lineno);
     438void p_psFree(psPtr ptr, const char *filename, unsigned int lineno);
    439439\end{prototype}
    440440%
    … …  
    481481
    482482\begin{prototype}
    483 void psMemSetDeallocator(void* ptr, psFreeFcn freeFcn);     
    484 psFreeFcn psMemGetDeallocator(void* ptr);     
     483void psMemSetDeallocator(psPtr ptr, psFreeFcn freeFcn);     
     484psFreeFcn psMemGetDeallocator(const psPtr ptr);     
    485485\end{prototype}
    486486
    … …  
    526526\item \code{psMemExhaustedCallbackDefault}
    527527\item \code{psMemProblemCallbackDefault}
    528 \item \code{psMemAllocateCallbackDefault}
     528\item \code{psMemAllocCallbackDefault}
    529529\item \code{psMemFreeCallbackDefault}
    530530\end{itemize}
    … …  
    573573%
    574574\begin{datatype}
    575 typedef void (*psMemProblemCallback)(psMemBlock *ptr, char *file, int lineno);
     575typedef void (*psMemProblemCallback)(psMemBlock *ptr, char *filename, unsigned int lineno);
    576576\end{datatype}
    577577
    … …  
    588588detected by checking \code{psMemBlock.refCounter}.
    589589
    590 \subsubsubsection{\tt psMemAllocateCallback \& psMemFreeCallback}
    591 
    592 Two private variables, \code{p_psMemAllocateID} and
     590\subsubsubsection{\tt psMemAllocCallback \& psMemFreeCallback}
     591
     592Two private variables, \code{p_psMemAllocID} and
    593593\code{p_psMemFreeID}, can be used to trace the allocation and freeing
    594 of specific memory blocks.  If the first (\code{p_psMemAllocateID}) is
     594of specific memory blocks.  If the first (\code{p_psMemAllocID}) is
    595595set and a memory block with that ID is allocated, the corresponding
    596596callback is called just before memory is returned to the calling
    … …  
    602602%
    603603\begin{prototype}
    604 psMemoryId psMemAllocateCallbackSetID(psMemoryId id);
    605 psMemoryId psMemFreeCallbackSetID(psMemoryId id);
     604psMemId psMemAllocCallbackSetID(psMemId id);
     605psMemId psMemFreeCallbackSetID(psMemId id);
    606606\end{prototype}
    607607%
    … …  
    609609%
    610610\begin{datatype}
    611 typedef psMemoryId (*psMemAllocateCallback)(const psMemBlock *ptr);
    612 \end{datatype}
    613 
    614 \begin{prototype}
    615 psMemAllocateCallback psMemAllocateCallbackSet(psMemAllocateCallback func);
    616 \end{prototype}
    617 
    618 \begin{datatype}
    619 typedef psMemoryId (*psMemFreeCallback)(const psMemBlock *ptr);
     611typedef psMemId (*psMemAllocCallback)(const psMemBlock *ptr);
     612\end{datatype}
     613
     614\begin{prototype}
     615psMemAllocCallback psMemAllocCallbackSet(psMemAllocCallback func);
     616\end{prototype}
     617
     618\begin{datatype}
     619typedef psMemId (*psMemFreeCallback)(const psMemBlock *ptr);
    620620\end{datatype}
    621621
    622622\begin{prototype}
    623623psMemFreeCallback psMemFreeCallbackSet(psMemFreeCallback func);
    624 psMemoryId psMemGetId(void);
     624psMemId psMemGetId(void);
    625625\end{prototype}
    626626%
    627627The callback functions are called with a pointer to the corresponding
    628628memory block.  The routines \code{psMemFreeCallbackIDSet} and
    629 \code{psMemAllocateCallbackIDSet} accept the desired ID value and return the
     629\code{psMemAllocCallbackIDSet} accept the desired ID value and return the
    630630old value to the user.  The return values of the handlers installed by
    631 \code{psMemAllocateCallbackSet} and \code{psMemFreeCallbackSet} are
    632 used to increment the values of \code{p_psMemAllocateID} and
     631\code{psMemAllocCallbackSet} and \code{psMemFreeCallbackSet} are
     632used to increment the values of \code{p_psMemAllocID} and
    633633\code{p_psMemFreeID} respectively.  For example, a return value of
    634634\code{0} implies that the value is unchanged; if the value is \code{2}
    … …  
    649649%
    650650\begin{prototype}
    651 int psMemCheckLeaks(psMemoryId id0, psMemBlock ***array, FILE *fd, bool persistence);
     651int psMemCheckLeaks(psMemId id0, psMemBlock ***array, FILE *fd, bool persistence);
    652652int psMemCheckCorruption(bool abort_on_error);
    653653\end{prototype}
    … …  
    828828%
    829829\begin{prototype}
    830 void psTrace(const char *facil, int myLevel,...);
     830void psTrace(const char *facil, int level,...);
    831831\end{prototype}
    832832%
    … …  
    835835\code{vprintf} functions.  This command specifies the name of the
    836836facility to which the message belongs (\code{facil}), the trace level
    837 for this message in that facility (\code{myLevel}) and the message
     837for this message in that facility (\code{level}) and the message
    838838itself.
    839839
    … …  
    857857\code{psTrace}) must be printed if and only if
    858858\code{psTraceGetLevel(facil)} returns a value greater than or equal to
    859 the value of \code{myLevel} for that message.  That is, a larger
     859the value of \code{level} for that message.  That is, a larger
    860860number for the trace level corresponds to lower-level statements, and
    861861hence is more verbose.
    … …  
    956956%
    957957\begin{prototype}
    958 void psLogMsg(const char *name, int myLevel, const char *fmt, ...);
    959 void psLogMsgV(const char *name, int myLevel, const char *fmt, va_list ap);
     958void psLogMsg(const char *name, int level, const char *fmt, ...);
     959void psLogMsgV(const char *name, int level, const char *fmt, va_list ap);
    960960\end{prototype}
    961961where \code{name} is a word to describe the source of the message,
    962 \code{myLevel} is the severity level of this message, and \code{fmt}
     962\code{level} is the severity level of this message, and \code{fmt}
    963963is a printf-style formatting statement defining the actual message,
    964964and is followed by the arguments to the formatting code.  The second
    … …  
    983983This function returns the previous log level.  A specific message
    984984invoked with \code{psLogMsg} is only printed if its value of
    985 \code{myLevel} is less than the current value set by
     985\code{level} is less than the current value set by
    986986\code{psLogSetLevel}.  The default log level is set to
    987987\code{PS_LOG_INFO}.
    … …  
    10591059returns the error code.
    10601060\begin{prototype}
    1061 psErrorCode p_psError(const char *file, int lineno, const char *func, psErrorCode code, bool new,
     1061psErrorCode p_psError(const char *filename, unsigned int lineno, const char *func, psErrorCode code, bool new,
    10621062                      const char *fmt, ...);
    10631063\end{prototype}
    … …  
    13401340In addition, we specify two functions for working with \code{psScalar} data:
    13411341\begin{prototype}
    1342 psScalar *psScalarAlloc(psC64 value, psElemType dataType);
     1342psScalar *psScalarAlloc(complex double value, psElemType type);
    13431343psScalar *psScalarCopy(const psScalar *value);
    13441344\end{prototype}
    13451345The first creates a \code{psType}-ed structure from a constant value,
    1346 casting it as appropriate based on the \code{dataType}.  The second
     1346casting it as appropriate based on the \code{type}.  The second
    13471347copies the provided \code{psScalar} value.  This latter function is
    13481348necessary to keep a copy of an existing \code{psScalar} value, since
    … …  
    16051605specified \code{position}.
    16061606
    1607 \begin{prototype}
    1608 psArray *psArraySort(psArray *array, int (*compare)(const void **a, const void **b) );
     1607\begin{datatype}
     1608typedef int (*psComparePtrFunc) (
     1609    const void **a,                    ///< first comparison target
     1610    const void **b                     ///< second comparison target
     1611);
     1612\end{datatype}
     1613
     1614\begin{prototype}
     1615psArray *psArraySort(psArray *array, psComparePtrFunc func);
    16091616\end{prototype}
    16101617An array may be sorted using \code{psArraySort}, which requires the
    … …  
    16521659
    16531660\begin{prototype}
    1654 psList *psListAlloc(const void *data);
     1661psList *psListAlloc(psPtr data);
    16551662\end{prototype}
    16561663Create a list.  This function may take a pointer to a data item, or it
    … …  
    17241731
    17251732\begin{prototype}
    1726 bool psListAdd(psList *list, int location, const void *data);
    1727 bool psListAddAfter(psListIterator *iterator, const void *data);
    1728 bool psListAddBefore(psListIterator *iterator, const void *data);
     1733bool psListAdd(psList *list, int location, psPtr data);
     1734bool psListAddAfter(psListIterator *iterator, psPtr data);
     1735bool psListAddBefore(psListIterator *iterator, psPtr data);
    17291736\end{prototype}
    17301737the first function, \code{psListAdd}, adds an entry to the \code{list}
    … …  
    17421749
    17431750\begin{prototype}
    1744 void *psListGet(psList *list, int location);
    1745 void *psListGetAndIncrement(psListIterator *iterator);
    1746 void *psListGetAndDecrement(psListIterator *iterator);
     1751psPtr psListGet(psList *list, int location);
     1752psPtr psListGetAndIncrement(psListIterator *iterator);
     1753psPtr psListGetAndDecrement(psListIterator *iterator);
    17471754\end{prototype}
    17481755A data item may be retrieved from the list with these functions.  The
    … …  
    17731780\begin{prototype}
    17741781bool psListRemove(psList *list, int location)
    1775 bool psListRemoveData(psList *list, const void *data);
     1782bool psListRemoveData(psList *list, psPtr data);
    17761783\end{prototype}
    17771784A data item may be removed from the list with these functions.  For
    … …  
    18001807
    18011808\begin{prototype}
    1802 psList *psListSort(psList *list, int (*compare)(const void **a, const void **b) );
     1809psList *psListSort(psList *list, psComparePtrFunc func);
    18031810\end{prototype}
    18041811A list may be sorted using \code{psListSort}, which requires the
    … …  
    18551862A hash table is created with the following function:
    18561863\begin{prototype}
    1857 psHash *psHashAlloc(psS32 nbuckets);
     1864psHash *psHashAlloc(psU32 nalloc);
    18581865\end{prototype}
    18591866which allocates the space for the hash table, creating and
    … …  
    18641871A data item may be added to the hash table with the function:
    18651872\begin{prototype}
    1866 bool psHashAdd(psHash *table, const char *key, psPtr data);
     1873bool psHashAdd(psHash *hash, const char *key, psPtr data);
    18671874\end{prototype}
    18681875In this function, the value of the string \code{key} is used to
    … …  
    18751882The data associated with a given key may be found with the function:
    18761883\begin{prototype}
    1877 void *psHashLookup(const psHash *table, const char *key);
     1884psPtr psHashLookup(const psHash *hash, const char *key);
    18781885\end{prototype}
    18791886which returns the data value pointed to by the element associated with
    … …  
    18811888a specific key may be removed (deleted) with the function:
    18821889\begin{prototype}
    1883 bool psHashRemove(psHash *table, const char *key);
     1890bool psHashRemove(psHash *hash, const char *key);
    18841891\end{prototype}
    18851892The function returns a value of \code{true} if the operation was
    … …  
    18881895The function
    18891896\begin{prototype}
    1890 psList *psHashKeyList(const psHash *table);
     1897psList *psHashKeyList(const psHash *hash);
    18911898\end{prototype}
    18921899returns the complete list of defined keys associated with the
    … …  
    18941901
    18951902\begin{prototype}
    1896 psArray *psHashToArray(const psHash *table);
     1903psArray *psHashToArray(const psHash *hash);
    18971904\end{prototype}
    18981905This function places the data in a \code{psHash} into a \code{psArray}
    … …  
    19561963\begin{prototype}
    19571964psLookupTable *psLookupTableAlloc(const char *filename, ///< File from which to read
    1958                                   const char *format ///< scanf-like format string
     1965                                  const char *format, ///< scanf-like format string
    19591966                                  int indexCol ///< Column of the index vector (starting at zero)
    19601967                                  );
    … …  
    20002007functions:
    20012008\begin{prototype}
    2002 psF64 psLookupTableInterpolate(const psLookupTable *table, psF64 index, int column, psLookupStatusType *status);
    2003 psVector *psLookupTableInterpolateAll(const psLookupTable *table, psF64 index, psVector *stats);
     2009double psLookupTableInterpolate(const psLookupTable *table, double index, int column, psLookupStatusType *status);
     2010psVector *psLookupTableInterpolateAll(const psLookupTable *table, double index, psVector *stats);
    20042011\end{prototype}
    20052012Both functions shall interpolate the \code{table} at the provided
    … …  
    20542061We also require the corresponding constructor and destructor:
    20552062\begin{prototype}
    2056 psBitSet *psBitSetAlloc(psS32 n);
     2063psBitSet *psBitSetAlloc(psU32 nalloc);
    20572064\end{prototype}
    20582065where \code{n} is the requested number of bits.
    … …  
    20682075
    20692076\begin{prototype}
    2070 psBitSet *psBitSetSet(psBitSet *bitSet, psS32 bit);
    2071 psBitSet* psBitSetClear(psBitSet *bitSet, psS32 bit);
     2077psBitSet *psBitSetSet(psBitSet *bitSet, psU32 bit);
     2078psBitSet* psBitSetClear(psBitSet *bitSet, psU32 bit);
    20722079psBitSet *psBitSetOp(psBitSet *outBitSet, const psBitSet *inBitSet1, const char *operator, const psBitSet *inBitSet2);
    20732080psBitSet *psBitSetNot(psBitSet *outBitSet, const psBitSet *inBitSet);
    2074 bool psBitSetTest(const psBitSet *bitSet, psS32 bit);
     2081bool psBitSetTest(const psBitSet *bitSet, psU32 bit);
    20752082char *psBitSetToString(const psBitSet* bitSet);
    20762083\end{prototype}
    … …  
    24182425To evaluate the polynomials at specific coordinates, we define:
    24192426\begin{prototype}
    2420 psF64 psPolynomial1DEval(const psPolynomial2D *myPoly,
     2427psF64 psPolynomial1DEval(const psPolynomial2D *poly,
    24212428                         psF64 x);
    2422 psF64 psPolynomial2DEval(const psPolynomial2D *myPoly,
     2429psF64 psPolynomial2DEval(const psPolynomial2D *poly,
    24232430                         psF64 x,
    24242431                         psF64 y);               
    2425 psF64 psPolynomial3DEval(const psPolynomial2D *myPoly,
     2432psF64 psPolynomial3DEval(const psPolynomial2D *poly,
    24262433                         psF64 x,
    24272434                         psF64 y,
    24282435                         psF64 z);                 
    2429 psF64 psPolynomial4DEval(const psPolynomial2D *myPoly,
     2436psF64 psPolynomial4DEval(const psPolynomial2D *poly,
    24302437                         psF64 x,
    24312438                         psF64 y,
    … …  
    24362443In the event that several evaluations are required, we also define:
    24372444\begin{prototype}
    2438 psVector *psPolynomial1DEvalVector(const psPolynomial2D *myPoly,
     2445psVector *psPolynomial1DEvalVector(const psPolynomial2D *poly,
    24392446                                   const psVector *x);
    2440 psVector *psPolynomial2DEvalVector(const psPolynomial2D *myPoly,
     2447psVector *psPolynomial2DEvalVector(const psPolynomial2D *poly,
    24412448                                   const psVector *x,
    24422449                                   const psVector *y);
    2443 psVector *psPolynomial3DEvalVector(const psPolynomial2D *myPoly,
     2450psVector *psPolynomial3DEvalVector(const psPolynomial2D *poly,
    24442451                                   const psVector *x,
    24452452                                   const psVector *y,
    24462453                                   const psVector *z);
    2447 psVector *psPolynomial4DEvalVector(const psPolynomial2D *myPoly,
     2454psVector *psPolynomial4DEvalVector(const psPolynomial2D *poly,
    24482455                                   const psVector *x,
    24492456                                   const psVector *y,
    … …  
    27162723
    27172724\begin{prototype}
    2718 psPolynomial1D *psVectorFitPolynomial1D(psPolynomial1D *myPoly,
     2725psPolynomial1D *psVectorFitPolynomial1D(psPolynomial1D *poly,
    27192726                                        const psVector *mask,
    27202727                                        unsigned int    maskValue
    … …  
    27222729                                        const psVector *fErr
    27232730                                        const psVector *x);
    2724 psPolynomial2D *psVectorFitPolynomial2D(psPolynomial1D *myPoly,
     2731psPolynomial2D *psVectorFitPolynomial2D(psPolynomial1D *poly,
    27252732                                        const psVector *mask,
    27262733                                        unsigned int    maskValue
    … …  
    27292736                                        const psVector *x,
    27302737                                        const psVector *y);
    2731 psPolynomial3D *psVectorFitPolynomial3D(psPolynomial1D *myPoly,
     2738psPolynomial3D *psVectorFitPolynomial3D(psPolynomial1D *poly,
    27322739                                        const psVector *mask,
    27332740                                        unsigned int    maskValue
    … …  
    27372744                                        const psVector *y,
    27382745                                        const psVector *z);
    2739 psPolynomial4D *psVectorFitPolynomial4D(psPolynomial1D *myPoly,
     2746psPolynomial4D *psVectorFitPolynomial4D(psPolynomial1D *poly,
    27402747                                        const psVector *mask,
    27412748                                        unsigned int    maskValue
    … …  
    27482755\end{prototype}
    27492756These functions return the polynomial that best fits the input data.
    2750 The provided polynomial, \code{myPoly}, specifies the fit order, and
     2757The provided polynomial, \code{poly}, specifies the fit order, and
    27512758will be returnd with the best-fit coefficients.  The dependent
    27522759variable and its error (\code{f, fErr}) are provided along with the
    … …  
    27622769
    27632770\begin{prototype}
    2764 psPolynomial1D *psVectorClipFitPolynomial1D(psPolynomial1D *myPoly,
     2771psPolynomial1D *psVectorClipFitPolynomial1D(psPolynomial1D *poly,
    27652772                                        psStats            *stats,
    27662773                                        const psVector     *mask,
    … …  
    27692776                                        const psVector     *fErr
    27702777                                        const psVector     *x);
    2771 psPolynomial2D *psVectorClipFitPolynomial2D(psPolynomial1D *myPoly,
     2778psPolynomial2D *psVectorClipFitPolynomial2D(psPolynomial1D *poly,
    27722779                                        psStats            *stats,
    27732780                                        const psVector     *mask,
    … …  
    27772784                                        const psVector     *x,
    27782785                                        const psVector     *y);
    2779 psPolynomial3D *psVectorClipFitPolynomial3D(psPolynomial1D *myPoly,
     2786psPolynomial3D *psVectorClipFitPolynomial3D(psPolynomial1D *poly,
    27802787                                        psStats            *stats,
    27812788                                        const psVector     *mask,
    … …  
    27862793                                        const psVector     *y,
    27872794                                        const psVector     *z);
    2788 psPolynomial4D *psVectorClipFitPolynomial4D(psPolynomial1D *myPoly,
     2795psPolynomial4D *psVectorClipFitPolynomial4D(psPolynomial1D *poly,
    27892796                                        psStats            *stats,
    27902797                                        const psVector     *mask,
    … …  
    30753082\begin{prototype}
    30763083psImage *psImageRotate(psImage *out, const psImage *input, float angle,
    3077                        psC64 exposed, psImageInterpolateMode mode);
     3084                       complex double exposed, psImageInterpolateMode mode);
    30783085\end{prototype}
    30793086Rotate the input image by given angle, specified in radians.  The
    … …  
    30893096\begin{prototype}
    30903097psImage *psImageShift(psImage *out, const psImage *input,
    3091                       float dx, float dy, psC64 exposed, psImageInterpolateMode mode);
     3098                      float dx, float dy, complex double exposed, psImageInterpolateMode mode);
    30923099\end{prototype}
    30933100Shift image by an arbitrary number of pixels (\code{dx,dy}) in either
    … …  
    31983205
    31993206\begin{prototype}
    3200 psC64 psImagePixelInterpolate(const psImage *input, float x, float y,
     3207complex double psImagePixelInterpolate(const psImage *input, float x, float y,
    32013208                              const psImage *mask, unsigned int maskVal,
    3202                               psC64 unexposedValue, psImageInterpolateMode mode);
     3209                              complex double unexposedValue, psImageInterpolateMode mode);
    32033210\end{prototype}
    32043211Perform interpolation of image pixel values to the given fractional
    … …  
    33183325
    33193326typedef struct {
    3320     int n;                      // Number in use
    3321     const int nalloc;           // Number allocated
     3327    psU32 n;                    // Number in use
     3328    const psU32 nalloc;         // Number allocated
    33223329    psPixelCoord *data;         // The pixel coordinates
    33233330} psPixels;
    … …  
    33253332
    33263333\begin{prototype}
    3327 psPixels *psPixelsAlloc(int nalloc);
    3328 psPixels *psPixelsRealloc(psPixels *pixels, int nalloc);
     3334psPixels *psPixelsAlloc(psU32 nalloc);
     3335psPixels *psPixelsRealloc(psPixels *pixels, psU32 nalloc);
    33293336\end{prototype}
    33303337
    … …  
    39713978typedef struct {
    39723979    psList *list;                       ///< list of psMetadataItem
    3973     psHash *table;                      ///< hash table of the same metadata
     3980    psHash *hash;                       ///< hash table of the same metadata
    39743981} psMetadata;
    39753982\end{datatype}
    … …  
    40394046
    40404047\begin{prototype}
    4041 bool psMetadataAddItem(psMetadata *md, const psMetadataItem *item, int location, int mode);
     4048bool psMetadataAddItem(psMetadata *md, const psMetadataItem *item, psS32 location, psS32 flags);
    40424049bool psMetadataAdd(psMetadata *md, int location, const char *name, int format, const char *comment, ...);
    40434050bool psMetadataAddV(psMetadata *md, int location, const char *name, int format, const char *comment,
    … …  
    42474254data type, printing is not allowed.
    42484255\begin{prototype}
    4249 bool psMetadataItemPrint(FILE *fd, const char *format, const psMetadataItem *md);
     4256bool psMetadataItemPrint(FILE *fd, const char *format, const psMetadataItem *item);
    42504257\end{prototype}
    42514258
    … …  
    45034510to a complete \code{psXMLDoc} (in memory) and vice versa:
    45044511\begin{prototype}
    4505 psXMLDoc *psMetadataToXMLDoc(const psMetadata *metadata);
     4512psXMLDoc *psMetadataToXMLDoc(const psMetadata *md);
    45064513psMetadata *psXMLDocToMetadata(const psXMLDoc *doc);
    45074514\end{prototype}
    … …  
    45184525into a complete \code{psXMLDoc} (also in memory), and vice versa:
    45194526\begin{prototype}
    4520 psXMLDoc *psXMLParseMemory(const char *buffer, int size);
    4521 int psXMLDocToMemory(const psXMLDoc *doc, char *buffer);
     4527psXMLDoc *psXMLParseMem(const char *buffer, int size);
     4528int psXMLDocToMem(const psXMLDoc *doc, char *buffer);
    45224529\end{prototype}
    45234530
    … …  
    48914898
    48924899\begin{prototype}
    4893 void *psFitsReadTableRowRaw(const int *nBytes, const psFits *fits, int row);
     4900void *psFitsReadTableRowRaw(size_t *size, const psFits *fits, int row);
    48944901\end{prototype}
    48954902This function reads a single row of the table in the extension pointed
    48964903at by the \code{psFits} file pointer.  The row number to be read is
    48974904given by \code{row}.  The result is returned as collection of
    4898 \code{nBytes} bytes allocated by the function.  The function must
     4905\code{size} bytes allocated by the function.  The function must
    48994906apply the needed byte-swapping on the data in the row based on the
    49004907description of the table data in the table header.  \tbr{we may need
    … …  
    49234930
    49244931\begin{prototype}
    4925 psArray *psFitsReadTableRaw(int *nBytes, const psFits *fits);
     4932psArray *psFitsReadTableRaw(size_t *size, const psFits *fits);
    49264933\end{prototype}
    49274934This function reads the entire data block from a table into the a
    49284935\code{psArray}, with one element of the array per row.  The number of
    4929 bytes per row is returned in \code{nBytes}.  The function must apply
     4936bytes per row is returned in \code{size}.  The function must apply
    49304937the needed byte-swapping on the data in each row based on the
    49314938description of the table data in the table header.
    … …  
    50445051
    50455052\begin{prototype}
    5046 psF64 *psTimeToLMST(psTime *time, psF64 longitude);
     5053double psTimeToLMST(psTime *time, double longitude);
    50475054\end{prototype}
    50485055
    … …  
    51095116
    51105117\begin{prototype}
    5111 psTime *psTimeFromJD(double input);
    5112 psTime *psTimeFromMJD(double input);
    5113 psTime *psTimeFromISO(const char *input, psTimeType timeSystem);
     5118psTime *psTimeFromJD(double jd);
     5119psTime *psTimeFromMJD(double mjd);
     5120psTime *psTimeFromISO(const char *input, psTimeType type);
    51145121psTime *psTimeFromTimeval(const timeval *input);
    51155122psTime *psTimeFromUTC(psS64 sec, psU32 nsec, bool leapsecond);
    … …  
    51245131
    51255132\begin{prototype}
    5126 psTime *psTimeMath(const psTime *time, psF64 delta);
    5127 psF64 psTimeDelta(const psTime *time1, const psTime *time2);
     5133psTime *psTimeMath(const psTime *time, double delta);
     5134double psTimeDelta(const psTime *time1, const psTime *time2);
    51285135\end{prototype}
    51295136
Note: See TracChangeset for help on using the changeset viewer.