value.h

Go to the documentation of this file.

/* Copyright (C) 2018 Chris Piker <chris-piker@uiowa.edu>
 *
 * This file is part of das2C, the Core Das2 C Library.
 *
 * das2C is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 2.1 as published
 * by the Free Software Foundation.
 *
 * das2C is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
 * more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 2.1 along with das2C; if not, see <http://www.gnu.org/licenses/>.
 */
 
#include <stdint.h>
 
#include <das3/util.h>
#include <das3/units.h>   /* das_sem_default needs das_units to read calendar reps */
 
#ifndef _das_value_h_
#define _das_value_h_
 
#ifdef __cplusplus
extern "C" {
#endif
   
#define DAS_FILL_VALUE -1e31
   
#define DAS_INT64_FILL -0x7FFFFFFFFFFFFFFFL
#define DAS_INT32_FILL -0x7FFFFFFF
 
   
typedef struct das_byte_seq_t{
   ubyte* ptr;
   size_t      sz;
} das_byte_seq;
 
typedef struct das_const_byte_seq_t{
   const ubyte* ptr;
   size_t sz;
} das_cbyte_seq;
 
#define DAS_BS_NULL  ((das_byte_seq){NULL, 0})
#define DAS_CBS_NULL ((das_cbyte_seq){NULL, 0})
 
 
#define VT_MIN_SIMPLE vtUByte
#define VT_MAX_SIMPLE vtTime
 
/* The types a das_datum stores in its own bytes, as against the ones it can
   only box a pointer to.  A contiguous range because the enum is ordered that
   way on purpose: everything from vtText up reaches outside itself.
   See das_datum_islocal() in datum.h. */
#define VT_MIN_LOCAL vtUByte
#define VT_MAX_LOCAL vtIndex
 
typedef enum das_val_type_e {
   
   vtUnknown = 0,
   
   /* VT_MIN_SIMPLE = vtUByte */
 
   vtUByte = 1,
 
   vtByte = 2,
   
   vtUShort = 3,
   
   vtShort = 4,
   
   vtUInt = 5,
 
   vtInt = 6,
   
   vtULong = 7,
 
   vtLong = 8,
   
   vtFloat = 9,
   
   vtDouble = 10,
 
   vtTime = 11,
 
   /* VT_MAX_SIMPLE = vtTime */
 
   /* The following type is not used by datums, but by array indexing elements 
    * that track the size and location of child dimensions */
   vtIndex = 12,
         
   /* The following two types are only used by variables and datums
    * 
    * When generating Datums from Arrays: 
    * 
    *   - If the array element type is etUnknown then vtByteSeq is used, size
    *      is element size.
    * 
    *   - If the array element type is etByte and the D2ARY_AS_STRING flag is
    *       set then vtText is used.
    * 
    *   - If the array element type is anything else and D2ARY_AS_SUBSEQ is
    *     set then vtByteSeq is used, size is element size times the size of
    *     the fastest moving index the location read.
    */
         
   vtText = 13,
 
   /* Include later: vtPixel = 14, */
 
   vtByteSeq = 15,
 
   vtComposite = 16
 
} das_val_type;
 
/* What one cell of a composite item holds.  
 *
 * This enum is a subset of what das_val_type can describe.
 *
 * Note there is no element for affine time.  A TT2000 point-time is stored as a
 * plain etLong, and the affine rule rides as a formalism in form.h, not as an
 * element type.  The bits of a time and a count are identical; only the
 * composition rules differ, and rules are not storage.  The one struct time
 * that IS an element is etTime, the das_time broken-down calendar wart. */
typedef enum das_elem_type_e {
   etUnknown = 0,   /* == vtUnknown */
   etUByte   = 1,   /* == vtUByte, also the byte-run cell of a <bytes> */
   etByte    = 2,   /* == vtByte  */
   etUShort  = 3,   /* == vtUShort */
   etShort   = 4,   /* == vtShort */
   etUInt    = 5,   /* == vtUInt  */
   etInt     = 6,   /* == vtInt   */
   etULong   = 7,   /* == vtULong */
   etLong    = 8,   /* == vtLong.  a TT2000 point-time is stored here */
   etFloat   = 9,   /* == vtFloat */
   etDouble  = 10,  /* == vtDouble */
   etTime    = 11   /* == vtTime.  das_time struct, broken-down-time wart */
} das_elem_type;
 
DAS_API bool das_elem_asDouble(das_elem_type et, const ubyte* p, double* pOut);
 
 
#ifndef _das_value_c
extern const char* DAS_ENC_BYTE;
extern const char* DAS_ENC_UBYTE;
extern const char* DAS_ENC_BEINT;
extern const char* DAS_ENC_BEUINT;
extern const char* DAS_ENC_BEREAL;
extern const char* DAS_ENC_LEINT;
extern const char* DAS_ENC_LEUINT;
extern const char* DAS_ENC_LEREAL;
extern const char* DAS_ENC_UTF8;
extern const char* DAS_ENC_BLOB;
extern const char* DAS_ENC_BASE64;
#endif
 
const char* das_enc_fromStr(const char* sEncType);
 
 
#ifndef _das_value_c
extern const char* DAS_SEM_BLOB;
extern const char* DAS_SEM_BOOL;
extern const char* DAS_SEM_DATE;
extern const char* DAS_SEM_INT;
extern const char* DAS_SEM_REAL;
extern const char* DAS_SEM_TEXT;
#endif
 
const char* das_sem_default(das_val_type vt, das_units units);
 
das_val_type das_vt_default(const char* sSemantic);
 
const char* das_sem_fromStr(const char* sSemantic);
 
DAS_API das_val_type das_vt_store_type(
   const char* sEncType, int nItemBytes, const char* sInterp
);
 
DAS_API const char* das_vt_serial_type(das_val_type et);
 
#define das_vt_isint(VT) ( VT >= vtUByte && VT <= vtLong )
 
#define das_vt_isreal(VT) ( VT == vtFloat || VT == vtDouble )
 
#define das_vt_rank(VT) ( ((VT==vtText)||(VT==vtByteSeq)) ? 1:0)
 
 
DAS_API const void* das_vt_fill(das_val_type vt);
 
DAS_API size_t das_vt_size(das_val_type vt);
 
DAS_API const char* das_vt_toStr(das_val_type vt);
 
DAS_API das_val_type das_vt_fromStr(const char* sType);
 
 
/* * Given a string and it's expected interpretation, return a suitable storage type
 */
/* DAS_API das_val_type das_vt_guess_store(const char* sInterp, const char* sValue); */
 
typedef int (*das_valcmp_func)(const ubyte*, const ubyte*);
 
DAS_API das_valcmp_func das_vt_getcmp(das_val_type vt);
 
DAS_API int das_value_cmpAny(
   const ubyte* pA, das_val_type vtA, const ubyte* pB, das_val_type vtB
);
 
 
#define das_vt_cmpAny das_value_cmpAny
 
/* In the future the token ID will come from the lexer, for now just make
 * something up*/
#define D2OP_PLUS 100
 
DAS_API das_val_type das_vt_merge(das_val_type right, int op, das_val_type left);
 
#define DAS_VAL_NOERR_RNG   0x1
#define DAS_VAL_ERR_RESLOSS 0x2
DAS_API DasErrCode das_value_binXform(
   das_val_type vtIn,  const ubyte* pValIn,  const ubyte* pFillIn,
   das_val_type vtOut,       ubyte* pValOut, const ubyte* pFillOut,
   uint32_t uFlags
);
 
DAS_API DasErrCode das_value_binop(
   int nOp, das_val_type vtL, const ubyte* pL, das_val_type vtR,
   const ubyte* pR, das_val_type vtOut, ubyte* pOut
);
 
DAS_API DasErrCode das_value_accum(
   das_val_type vt, ubyte* pAccum, const ubyte* pStep, ptrdiff_t nCount
);
 
DAS_API DasErrCode das_value_fmt(
   char* sBuf, int nBufLen, das_val_type vt, const char* sSemantic, int nFitTo
);
 
DAS_API void das_value_trimReal(char* sVal);
 
DAS_API DasErrCode das_value_fromStr(
   ubyte* pBuf, int uBufLen, das_val_type vt, const char* sStr
);
 
 
DAS_API bool das_str2double(const char* str, double* pRes);
 
 
DAS_API bool das_str2int(const char* str, int* pRes);
 
DAS_API bool das_str2bool(const char* str, bool* pRes);
 
DAS_API bool das_str2baseint(const char* str, int base, int* pRes);
 
DAS_API bool das_strn2baseint(const char* str, int nLen, int base, int* pRes);
 
/* Don't think these are used anywhere
typedef struct das_real_array{
   double* values;
   size_t length;
} das_real_array;
 
typedef struct das_creal_array{
   const double* values;
   size_t length;
} das_creal_array;
 
typedef struct das_int_array{
   int* values;
   size_t length;
} das_int_array;
 
typedef struct das_cint_array{
   const int* values;
   size_t length;
} das_cint_array;
*/
 
DAS_API double* das_csv2doubles(const char * s, int* nitems);
 
 
DAS_API char* das_doubles2csv(char* pBuf, size_t uBufSz, const double* pValues, int nValues);
 
 
DAS_API char* das_floats2csv(char* pBuf, size_t uBufSz, const float* pValues, int nValues);
 
 
#ifdef __cplusplus
}
#endif
 
#endif /* _das_value_h_ */