source: thirdparty/SZ/sz/src/VarSet.c @ 2c47b73

/**
 *  @file Variable.c
 *  @author Sheng Di
 *  @date July, 2016
 *  @brief TypeManager is used to manage the type array: parsing of the bytes and other types in between.
 *  (C) 2016 by Mathematics and Computer Science (MCS), Argonne National Laboratory.
 *      See COPYRIGHT in top-level directory.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "VarSet.h"
#include "sz.h"

void free_Variable_keepOriginalData(SZ_Variable* v)
{
        if(v->varName!=NULL)
                free(v->varName);       
        if(v->data!=NULL)
                free(v->compressedBytes);
        
        free(v);
}

/**
 * 
 * @deprecated
 * */
void free_Variable_keepCompressedBytes(SZ_Variable* v)
{
        if(v->varName!=NULL)
                free(v->varName);
        if(v->data!=NULL)
                free(v->data);
        if(v->multisteps!=NULL)
                free_multisteps(v->multisteps); 
        free(v);
}

void free_Variable_all(SZ_Variable* v)
{
        if(v->varName!=NULL)
                free(v->varName);
        if(v->data!=NULL)
                free(v->data);
        if(v->compressedBytes!=NULL)
                free(v->compressedBytes);
        if(v->multisteps!=NULL)
                free_multisteps(v->multisteps);
        free(v);
}

void SZ_batchAddVar(char* varName, int dataType, void* data, 
                        int errBoundMode, double absErrBound, double relBoundRatio, double pwRelBoundRatio, 
                        size_t r5, size_t r4, size_t r3, size_t r2, size_t r1)
{       
        if(sz_varset==NULL)
        {
                sz_varset = (SZ_VarSet*)malloc(sizeof(SZ_VarSet));
                sz_varset->header = (SZ_Variable*)malloc(sizeof(SZ_Variable));
                sz_varset->header->next = NULL;
                sz_varset->lastVar = sz_varset->header;
                sz_varset->count = 0;           
        }
        
        SZ_Variable* var = (SZ_Variable*)malloc(sizeof(SZ_Variable));
        memset(var, 0, sizeof(SZ_Variable));
        
        var->varName = (char*)malloc(strlen(varName)+1);
        memcpy(var->varName, varName, strlen(varName)+1);
        //var->varName = varName;
        var->dataType = dataType;
        var->r5 = r5;
        var->r4 = r4;
        var->r3 = r3;
        var->r2 = r2;
        var->r1 = r1;
        var->errBoundMode = errBoundMode;
        var->absErrBound = absErrBound;
        var->relBoundRatio = relBoundRatio;
        var->pwRelBoundRatio = pwRelBoundRatio;
        var->data = data;
        
        var->multisteps = (sz_multisteps*)malloc(sizeof(sz_multisteps));
        memset(var->multisteps, 0, sizeof(sz_multisteps));
        
        size_t dataLen = computeDataLength(r5, r4, r3, r2, r1);
        if(dataType==SZ_FLOAT)
        {
                var->multisteps->hist_data = (float*)malloc(sizeof(float)*dataLen);
                memset(var->multisteps->hist_data, 0, sizeof(float)*dataLen);
        }
        else if(dataType==SZ_DOUBLE)
        {
                var->multisteps->hist_data = (double*)malloc(sizeof(double)*dataLen);
                memset(var->multisteps->hist_data, 0, sizeof(double)*dataLen);
        }
        var->compressedBytes = NULL;
        var->next = NULL;
        
        sz_varset->count ++;
        sz_varset->lastVar->next = var;
        sz_varset->lastVar = var;
}

int SZ_batchDelVar(char* varName)
{
        int state = SZ_batchDelVar_vset(sz_varset, varName);
        return state;
}

int SZ_batchDelVar_vset(SZ_VarSet* vset, char* varName)
{
        int delSuccess = SZ_NSCS;
        SZ_Variable* p = vset->header;
        SZ_Variable* q = p->next;
        while(q != NULL)
        {
                int cmpResult = strcmp(q->varName, varName);
                if(cmpResult==0)
                {
                        p->next = q->next;
                        free_Variable_all(q);
                        vset->count --;
                        delSuccess = SZ_SCES;
                        break;
                }
                p = p->next;
                q = q->next;    
        }
        
        return delSuccess;
}

SZ_Variable* SZ_searchVar(char* varName)
{
        SZ_Variable* p = sz_varset->header->next;
        while(p!=NULL)
        {
                int checkName = strcmp(p->varName, varName);
                if(checkName==0)
                        return p;
                p = p->next;
        }       
        return NULL;
}

void* SZ_getVarData(char* varName, size_t *r5, size_t *r4, size_t *r3, size_t *r2, size_t *r1)
{
        SZ_Variable* v = SZ_searchVar(varName);
        *r5 = v->r5;
        *r4 = v->r4;
        *r3 = v->r3;
        *r2 = v->r2;
        *r1 = v->r1;
        return (void*)v->data;
}

/**
 * 
 * int mode: SZ_MAINTAIN_VAR_DATA, Z_DESTROY_WHOLE_VARSET
 * */
void SZ_freeVarSet(int mode)
{
        free_VarSet_vset(sz_varset, mode);
}

//free_VarSet will completely destroy the SZ_VarSet, so don't do it until you really don't need it any more!
/**
 * 
 * int mode: SZ_MAINTAIN_VAR_DATA, Z_DESTROY_WHOLE_VARSET
 * */
void free_VarSet_vset(SZ_VarSet *vset, int mode)
{
        if(vset==NULL)
                return;
        SZ_Variable *p = vset->header;
        while(p->next!=NULL)
        {
                SZ_Variable *q = p->next;
                p->next = q->next;
                if(mode==SZ_MAINTAIN_VAR_DATA)
                        free_Variable_keepOriginalData(q);
                else if(mode==SZ_DESTROY_WHOLE_VARSET)
                        free_Variable_all(q);
        }
        free(sz_varset->header);
        free(vset);
}

void free_multisteps(sz_multisteps* multisteps)
{
        if(multisteps->hist_data!=NULL)
                free(multisteps->hist_data);
        free(multisteps);
}