base/drms/libs/api/drms_segment.h

Go to the documentation of this file.

#ifndef _DRMS_SEGMENT_H
#define _DRMS_SEGMENT_H

#include "drms_types.h"
#include "drms.h"
#include "drms_array.h"

/********************************************************/
/********                                        ********/
/******** Functions handling segment structures  ********/
/********                                        ********/
/********************************************************/

/**** External functions (for modules) ****/
#define name2seg(rec, name) drms_segment_lookup(rec, name)

#define num2seg(rec, num) drms_segment_lookupnum(rec, num)

/* @{ */
/* Look up a segment belonging to record by name. */
DRMS_Segment_t *drms_segment_lookup(DRMS_Record_t *record, const char *segname);

/* Look up a segment belonging to record by number. */
DRMS_Segment_t *drms_segment_lookupnum(DRMS_Record_t *record, int segnum);
/* @} */

DRMS_Segment_t *drms_segment_lookupindex(DRMS_Record_t *rec, int index, int followLink);

/* @{ */
/* Create stand-alone segments that contain pointers to/from target only. */
HContainer_t *drms_create_segment_prototypes(DRMS_Record_t *target, 
                         DRMS_Record_t *source, 
                         int *status);

/* Return a container of DRMS_SegmentInfo_t structs.  Caller owns the returned container. */
HContainer_t *drms_segment_createinfocon(DRMS_Env_t *drmsEnv, 
                     const char *seriesName, 
                     int *status);

void drms_segment_destroyinfocon(HContainer_t **info);
/* @} */


/* @{ */
/* Print contents of segment structure. */
void drms_segment_print(DRMS_Segment_t *seg);
void drms_segment_fprint(FILE *segfile, DRMS_Segment_t *seg);

/* Return absolute path to segment file in filename.
   filename must be able the hold at DRMS_MAXPATHLEN bytes. */
void drms_segment_filename(DRMS_Segment_t *seg, char *filename);

/* Estimated size of segment in bytes. */
long long drms_segment_size(DRMS_Segment_t *seg, int *status);

/* Returns 1 if the segments' meta-data match */
int drms_segment_segsmatch(const DRMS_Segment_t *s1, const DRMS_Segment_t *s2);
/* @} */




/* @{ */
/* Can modify segment dims only if the containing record is a record prototype */
int drms_segment_setdims(DRMS_Segment_t *seg, DRMS_SegmentDimInfo_t *di);

/* Get the record's segment axis dimensions. */
int drms_segment_getdims(DRMS_Segment_t *seg, DRMS_SegmentDimInfo_t *di);
/* @} */


/* @{ */
/* Set scaling for segment to accomodate data from the given array. */
void drms_segment_autoscale(DRMS_Segment_t *seg, 
                DRMS_Array_t *arr, 
                double *autobzero, 
                double *autobscale);

/* Set block sizes for tiled/blocked storage. */
void drms_segment_setblocksize(DRMS_Segment_t *seg, int *blksz);

/* Get block sizes for tiled/blocked storage. */
void drms_segment_getblocksize(DRMS_Segment_t *seg, int *blksz);
/* @} */

/********************************************************/
/********                                        ********/
/********    Functions handling segment data     ********/
/********                                        ********/
/********************************************************/

/**** Internal functions (not for modules) ****/

/* None exclusively for internal use only. */


/**** External functions (for modules) ****/

/* Open a data segment. 

   a) If the corresponding data file exists, read the 
   entire data array into memory. Convert it to the type given as 
   argument. If type=DRMS_TYPE_RAW then  the data is 
   read into an array of the same type it is stored as on disk.
   b) If the data file does not exist, then return a data array filed with 
   the MISSING value for the given type.
*/ 

/* @{ */

FILE *drms_segment_fopen(DRMS_Segment_t *seg, const char *newfilename, int append, int *status);

DRMS_Array_t *drms_segment_read(DRMS_Segment_t *seg, DRMS_Type_t type, 
                int *status);
DRMS_Array_t *drms_segment_readslice(DRMS_Segment_t *seg, DRMS_Type_t type, 
                     axislen_t *start, axislen_t *end, int *status);

int drms_segment_fclose(FILE *fptr);

/* Write the array argument to the file occupied by the
   segment argument. The array dimension and type must match the
   segment dimension and type. */
int drms_segment_write(DRMS_Segment_t *seg, DRMS_Array_t *arr, int autoscale);

int drms_segment_writewithkeys(DRMS_Segment_t *seg, DRMS_Array_t *arr, int autoscale);

int drms_segment_writeslice(DRMS_Segment_t *seg, 
                            DRMS_Array_t *arr, 
                            axislen_t *start, 
                            axislen_t *end, 
                            int autoscale);

int drms_segment_writeslice_ext(DRMS_Segment_t *seg, 
                                DRMS_Array_t *arr, 
                                axislen_t *start, 
                                axislen_t *end, 
                                int *finaldims,
                                int autoscale);

/* Write a file specified by filename argument to the file occupied by
   the segment argument. The filename of the segment is set.
 */
int drms_segment_write_from_file(DRMS_Segment_t *seg, const char *infile);
/* @} */


/* accessor functions */
static inline int drms_segment_getnaxis(DRMS_Segment_t *seg)
{
   return seg->info->naxis;
}

static inline int drms_segment_ranksort(const void *he1, const void *he2)
{
   DRMS_Segment_t *s1 = (DRMS_Segment_t *)hcon_getval(*((HContainerElement_t **)he1));
   DRMS_Segment_t *s2 = (DRMS_Segment_t *)hcon_getval(*((HContainerElement_t **)he2));
   
   XASSERT(s1 && s2);

   return (s1->info->segnum < s2->info->segnum) ? -1 : (s1->info->segnum > s2->info->segnum ? 1 : 0);
}

DRMS_Segment_t *drms_template_segment_followlink(DRMS_Segment_t *srcseg, int *statret);

#endif

---