---

CAVERNnet_datapack_c.hxx

/******************************************************************
 * CAVERNsoft
 * Copyright (C) 1994-2000 Electronic Visualization Laboratory,
 * all rights reserved
 * By Jason Leigh, Yong-joo Cho, Naveen Krishnaprasad, Chris Scharver,
 * Stuart Bailey, Atul Nayak, Shalini Venkataraman
 * University of Illinois at Chicago
 * 
 * This publication and its text and code may not be copied for commercial 
 * use without the express written permission of the University of Illinois
 * at Chicago
 * The contributors disclaim any representation of warranty: use this
 * code at your own risk.
 * Direct questions, comments etc to cavern@evl.uic.edu
 ******************************************************************/
#ifndef _CAVERN_DATAPACK_C_H
#define _CAVERN_DATAPACK_C_H

#ifdef CAVERN_USE_GLOBUS_DATA_PACK
#include "globus_dc.h"
#include "globus_config.h"
#else
#define FLOAT_SIZE 4
#define DOUBLE_SIZE 8
#define INT_SIZE 4
#if (_MIPS_SZLONG==64)
#define LONG_SIZE 8
#else
#define LONG_SIZE 4
#endif
#define INT32_SIZE 4
#define INT64_SIZE 8
#define CHAR_SIZE 1
#endif

typedef int int32;

#ifdef WIN32 
typedef __int64 int64;
#elif (_MIPS_SZLONG==64)
typedef long int64;
#else 
typedef long long int64;
#endif

class CAVERNnet_datapack_c {


public:
        CAVERNnet_datapack_c() {
                running = 0; size = 0;
                start = 0;
        }

        


        static const int OK/* = 0*/;
        static const int FAILED/* = -1*/;

        void initPack(char *buffer, int buffersize);

        void initUnpack(char *buffer, int buffersize);

        char *getBuffer() { return (char *)start;}

        int getBufferMaxSize() { return size;}

        int getBufferFilledSize() {return running - start;}

        int packFloat(float val);

        int packInt(int val) ;

        int packInt32(int32 val);

        int packLong(long val) ;

        int packInt64(int64 val);

        int packDouble(double val);


        int packChar(char val) ;

        int pack(char* val, int sz) ;
        
        int packFloatArray(float* val, int sz) ;

        int packDoubleArray(double* val, int sz) ;

        int packIntArray(int* val, int sz) ;

        int packInt32Array(int32* val, int sz) ;
   
        int packInt64Array(int64* val, int sz) ;

        int packLongArray(long* val, int sz) ;
    
        int unpackFloat(float *Answer) ;

        int unpackInt(int *Answer) ;

        int unpackInt32(int32 *Answer) ;

        int unpackLong(long *Answer) ;

        int unpackInt64(int64 *Answer) ;

        int unpackDouble(double *Answer)  ;

        int unpackChar(char *Answer) ;

        int unpack(char *Answer, int sz) ;

    int unpackFloatArray(float* Answer, int sz);
   
    int unpackDoubleArray(double* Answer, int sz);
   
    int unpackIntArray(int* Answer, int sz);
   
    int unpackInt32Array(int32* Answer, int sz);

    int unpackInt64Array(int64* Answer, int sz);
   
    int unpackLongArray(long* Answer, int sz);
    
        int checkspace(unsigned int incoming_size);

#ifdef CAVERN_USE_GLOBUS_DATA_PACK
        static int sizeof_float(unsigned int cnt=1){return 1+nexus_dc_sizeof_float(cnt);};
#else
        static int sizeof_float(unsigned int cnt=1){return FLOAT_SIZE * cnt;};
#endif

#ifdef CAVERN_USE_GLOBUS_DATA_PACK
        static int sizeof_int(unsigned int cnt=1){return 1+nexus_dc_sizeof_int(cnt);};
#else
        static int sizeof_int(unsigned int cnt=1){return INT_SIZE * cnt;};
#endif

#ifndef CAVERN_USE_GLOBUS_DATA_PACK
        static int sizeof_int64(unsigned int cnt=1){return INT64_SIZE * cnt;};
#endif

#ifndef CAVERN_USE_GLOBUS_DATA_PACK
        static int sizeof_int32(unsigned int cnt=1){return INT32_SIZE * cnt;};
#endif
        
#ifdef CAVERN_USE_GLOBUS_DATA_PACK
        static int sizeof_long(unsigned int cnt=1){return 1+nexus_dc_sizeof_long(cnt);};
#else
        static int sizeof_long(unsigned int cnt=1){return LONG_SIZE * cnt;};
#endif

#ifdef CAVERN_USE_GLOBUS_DATA_PACK
        static int sizeof_char(unsigned int cnt=1){return 1+nexus_dc_sizeof_char(cnt);};
#else
        static int sizeof_char(unsigned int cnt=1){return CHAR_SIZE * cnt;};
#endif

#ifdef CAVERN_USE_GLOBUS_DATA_PACK
        static int sizeof_double(unsigned int cnt=1){return 1+nexus_dc_sizeof_double(cnt);};
#else
        static int sizeof_double(unsigned int cnt=1){return DOUBLE_SIZE * cnt;};
#endif




private:
        unsigned long size;
#ifdef CAVERN_USE_GLOBUS_DATA_PACK
        nexus_byte_t *running;
        nexus_byte_t *start;
        int sender_format;
#else
        unsigned char *running;
        unsigned char *start;
#endif

};

#endif

---