Ignore:
Timestamp:
06/09/06 14:26:57 (18 years ago)
Author:
gumbau
Message:
 
File:
1 edited

Legend:

Unmodified
Added
Removed

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoSerializer.cpp

    r980 r1009  
    11#include "GeoSerializer.h" 
    22 
    3  
    4 namespace Geometry 
    5 { 
    6         //--------------------------------------------------------------------- 
    7         Serializer::Serializer(String name, Mode mode) 
    8                 : mMode(mode) 
    9                 { 
    10                         char *char_mode = 0; 
    11                         switch (mMode) 
    12                         { 
    13                                 case READ :  
    14                                         char_mode = "rb";  
    15                                         break; 
    16                                 case APPEND: 
    17                                         char_mode = "a+b"; 
    18                                         break; 
    19                                 case WRITE: 
    20                                         char_mode = "wb"; 
    21                                         break; 
    22                         } 
    23  
    24                         mFile = fopen(name.c_str(),char_mode); 
    25                         mSize = 0; 
    26                         assert(mFile); 
    27                 } 
    28  
    29         //--------------------------------------------------------------------- 
    30         Serializer::~Serializer() 
    31         { 
    32                 fflush(mFile); 
    33                 fclose(mFile); 
    34         } 
    35  
    36         //--------------------------------------------------------------------- 
    37         void Serializer::WriteArray(const float* const pFloat, size_t count) 
    38         { 
    39 #       if GEO_ENDIAN == GEO_ENDIAN_BIG 
    40                 float *float_to_write = (float *)malloc(sizeof(float) * count); 
    41                 memcpy(float_to_write, pFloat, sizeof(float) * count); 
    42  
    43                 flipToLittleEndian(float_to_write, sizeof(float), count); 
    44                 writeData(float_to_write, sizeof(float), count); 
    45  
    46                 free(float_to_write); 
     3using   namespace       Geometry; 
     4 
     5//--------------------------------------------------------------------------- 
     6//      Constructor. 
     7//--------------------------------------------------------------------------- 
     8Serializer::Serializer(String name, Mode mode): mMode(mode) 
     9{ 
     10        char *char_mode = 0; 
     11 
     12        switch (mMode) 
     13        { 
     14                case READ :  
     15                        char_mode = "rb";  
     16                        break; 
     17                case APPEND: 
     18                        char_mode = "a+b"; 
     19                        break; 
     20                case WRITE: 
     21                        char_mode = "wb"; 
     22                        break; 
     23        } 
     24 
     25        mFile = fopen(name.c_str(),char_mode); 
     26        mSize = 0; 
     27 
     28        assert(mFile); 
     29} 
     30 
     31//--------------------------------------------------------------------------- 
     32//      Destroyer. 
     33//--------------------------------------------------------------------------- 
     34Serializer::~Serializer() 
     35{ 
     36        fflush(mFile); 
     37        fclose(mFile); 
     38} 
     39 
     40//--------------------------------------------------------------------------- 
     41//      Write array of floats. 
     42//--------------------------------------------------------------------------- 
     43void Serializer::WriteArray(const float* const pFloat, size_t count) 
     44{ 
     45#       if GEO_ENDIAN == GEO_ENDIAN_BIG 
     46        float *float_to_write = (float *)malloc(sizeof(float) * count); 
     47        memcpy(float_to_write, pFloat, sizeof(float) * count); 
     48 
     49        flipToLittleEndian(float_to_write, sizeof(float), count); 
     50        writeData(float_to_write, sizeof(float), count); 
     51 
     52        free(float_to_write); 
    4753#       else 
    48                 WriteData(pFloat, sizeof(float), count); 
    49 #       endif 
    50         } 
    51  
    52         //--------------------------------------------------------------------- 
    53         void Serializer::WriteArray(const uint16* const pShort, size_t count = 1) 
    54         { 
    55 #       if GEO_ENDIAN == GEO_ENDIAN_BIG 
    56                 unsigned short *short_to_write = (unsigned short *)malloc(sizeof(unsigned short) * count); 
    57                 memcpy(short_to_write, pShort, sizeof(unsigned short) * count); 
    58  
    59                 flipToLittleEndian(short_to_write, sizeof(unsigned short), count); 
    60                 WriteData(short_to_write, sizeof(unsigned short), count); 
    61  
    62                 free(short_to_write); 
     54        WriteData(pFloat, sizeof(float), count); 
     55#       endif 
     56} 
     57 
     58//--------------------------------------------------------------------------- 
     59//      Write array of shots. 
     60//--------------------------------------------------------------------------- 
     61void Serializer::WriteArray(const uint16* const pShort, size_t count = 1) 
     62{ 
     63#       if GEO_ENDIAN == GEO_ENDIAN_BIG 
     64        unsigned short *short_to_write = (unsigned short *)malloc(sizeof(unsigned short) * count); 
     65        memcpy(short_to_write, pShort, sizeof(unsigned short) * count); 
     66 
     67        flipToLittleEndian(short_to_write, sizeof(unsigned short), count); 
     68        WriteData(short_to_write, sizeof(unsigned short), count); 
     69 
     70        free(short_to_write); 
    6371#       else 
    64                 WriteData(pShort, sizeof(unsigned short), count); 
    65 #       endif 
    66         } 
    67          
    68         //--------------------------------------------------------------------- 
    69         void Serializer::WriteArray(const uint32* const pInt, size_t count = 1) 
    70         { 
    71 #       if GEO_ENDIAN == GEO_ENDIAN_BIG 
    72                 unsigned int *int_to_write = (unsigned int *)malloc(sizeof(unsigned int) * count); 
    73                 memcpy(int_to_write, pInt, sizeof(unsigned int) * count); 
    74  
    75                 FlipToLittleEndian(int_to_write, sizeof(unsigned int), count); 
    76                 WriteData(int_to_write, sizeof(unsigned int), count); 
    77  
    78                 free(int_to_write); 
     72        WriteData(pShort, sizeof(unsigned short), count); 
     73#       endif 
     74} 
     75         
     76//--------------------------------------------------------------------------- 
     77//      Write array of integers. 
     78//--------------------------------------------------------------------------- 
     79void Serializer::WriteArray(const uint32* const pInt, size_t count = 1) 
     80{ 
     81#       if GEO_ENDIAN == GEO_ENDIAN_BIG 
     82        unsigned int *int_to_write = (unsigned int *)malloc(sizeof(unsigned int) * count); 
     83        memcpy(int_to_write, pInt, sizeof(unsigned int) * count); 
     84 
     85        FlipToLittleEndian(int_to_write, sizeof(unsigned int), count); 
     86        WriteData(int_to_write, sizeof(unsigned int), count); 
     87 
     88        free(int_to_write); 
    7989#       else 
    80                 WriteData(pInt, sizeof(unsigned int), count); 
    81 #       endif 
    82         } 
    83  
    84         //--------------------------------------------------------------------- 
    85         void Serializer::WriteArray(const bool* const pBool, size_t count = 1) 
    86         { 
    87                 //TODO: Apple has problems  
    88                 WriteData(pBool, sizeof(bool), count); 
    89         } 
    90          
    91         //--------------------------------------------------------------------- 
    92         void Serializer::WriteArray(const Vector3* const pDest, size_t count) 
    93         { 
    94                 for(size_t i = 0; i < count; ++i) 
    95                 { 
    96                         WriteArray(pDest[i].val,3); 
    97                 } 
    98         } 
    99          
    100         //--------------------------------------------------------------------- 
    101         void Serializer::WriteArray(const Vector2* const pDest, size_t count) 
    102         { 
    103                 for(size_t i = 0; i < count; ++i) 
    104                 { 
    105                         WriteArray(pDest[i].val,2); 
    106                 } 
    107         } 
    108  
    109         //--------------------------------------------------------------------- 
    110         void Serializer::WriteData(const void* const buf, size_t size, size_t count) 
    111         { 
    112                 size_t wcount = fwrite((void* const)buf, size, count, mFile); 
    113                 assert(wcount == count); 
    114                 mSize += size*count; 
    115         } 
    116  
    117         //--------------------------------------------------------------------- 
    118         void Serializer::ReadData(void *pDest, size_t size, size_t count) 
    119         { 
    120                 size_t rcount = fread(pDest,size,count,mFile); 
    121                 assert(rcount == count); 
    122                 mSize += size*count; 
    123         }; 
    124  
    125  
    126         // JGA 
    127         char * Serializer::miReadData(char *pDest, size_t pDestsize) 
    128         { 
    129                 return fgets(pDest, (int)pDestsize, mFile); 
    130         }; 
    131  
    132         void Serializer::miReadData2(void *pDest, size_t size, size_t count) 
    133         { 
    134                 size_t rcount = fread(pDest,size,count,mFile); 
    135                 assert(rcount == count); 
    136                 mSize += size*count; 
    137         }; 
    138         // fin JGA 
    139  
    140         //      GPR. 
    141         void    Serializer::WriteData(const     String  &string) 
    142         { 
    143                 fputs(string.c_str(), mFile); 
    144  
    145                 // Write terminating newline char 
    146                 //fputc('\n', mFile); 
    147  
    148                 mSize   +=      string.length(); 
    149         } 
    150         //      fin     GPR 
    151  
    152         void    Serializer::WriteData(const char        *string) 
    153         { 
    154                 fputs(string, mFile); 
    155  
    156                 // Write terminating newline char 
    157                 //fputc('\n', mFile); 
    158  
    159                 mSize   +=      strlen(string) /*+ 1*/; 
    160         } 
    161  
    162         //--------------------------------------------------------------------- 
    163         void Serializer::ReadArray(bool *pDest, size_t count) 
    164         { 
    165                 //TODO:: Apple has problmes with bools 
    166                 ReadData(pDest,sizeof(bool), count); 
    167         } 
    168  
    169         //--------------------------------------------------------------------- 
    170         void Serializer::ReadArray(float *pDest, size_t count) 
    171         { 
    172                 ReadData(pDest, sizeof(float), count); 
    173                 FlipFromLittleEndian(pDest, sizeof(float), count); 
    174         } 
    175          
    176         //--------------------------------------------------------------------- 
    177         void Serializer::ReadArray(unsigned short *pDest, size_t count) 
    178         { 
    179                 ReadData(pDest, sizeof(unsigned short), count); 
    180                 FlipFromLittleEndian(pDest, sizeof(unsigned short), count); 
    181         } 
    182          
    183         //--------------------------------------------------------------------- 
    184         void Serializer::ReadArray(unsigned int *pDest, size_t count) 
    185         { 
    186                 ReadData(pDest, sizeof(unsigned int), count); 
    187                 FlipFromLittleEndian(pDest, sizeof(unsigned int), count); 
    188         } 
    189          
    190         //--------------------------------------------------------------------- 
    191         void Serializer::ReadArray(Vector3 *pDest, size_t count) 
    192         { 
    193                 for(size_t i = 0; i < count; ++i) 
    194                 { 
    195                         ReadArray(pDest[i].val,3); 
    196                 } 
    197         } 
    198          
    199         //--------------------------------------------------------------------- 
    200         void Serializer::ReadArray(Vector2 *pDest, size_t count) 
    201         { 
    202                 for(size_t i = 0; i < count; ++i) 
    203                 { 
    204                         ReadArray(pDest[i].val,2); 
    205                 } 
    206         } 
    207  
    208         //--------------------------------------------------------------------- 
    209         void Serializer::FlipToLittleEndian(void *pData, size_t size, size_t count) 
    210         { 
    211 #       if GEO_ENDIAN == GEO_ENDIAN_BIG 
    212                 FlipEndian(pData, size, count); 
    213 #       endif 
    214         } 
    215  
    216         void Serializer::FlipFromLittleEndian(void *pData, size_t size, size_t count) 
    217         { 
    218 #       if GEO_ENDIAN == GEO_ENDIAN_BIG 
    219                 FlipEndian(pData, size, count); 
    220 #       endif 
    221         } 
    222  
    223         void Serializer::FlipEndian(void *pData, size_t size, size_t count) 
    224         { 
    225                 for(unsigned int index = 0; index < count; index++) 
    226                 { 
    227                         FlipEndian((void *)((char*)pData + (index * size)), size); 
    228                 } 
    229         } 
    230  
    231         void Serializer::FlipEndian(void *pData, size_t size) 
    232         { 
    233                 char swapByte; 
    234                 for(unsigned int byteIndex = 0; byteIndex < size/2; byteIndex++) 
    235                 { 
    236                         swapByte = *((char *)pData + byteIndex); 
    237                         *((char *)pData + byteIndex) = *((char *)pData + size - byteIndex - 1); 
    238                         *((char *)pData + size - byteIndex - 1) = swapByte; 
    239                 } 
    240         } 
    241  
    242 } 
    243  
     90        WriteData(pInt, sizeof(unsigned int), count); 
     91#       endif 
     92} 
     93 
     94//--------------------------------------------------------------------------- 
     95//      Write array of booleans. 
     96//--------------------------------------------------------------------------- 
     97void Serializer::WriteArray(const bool* const pBool, size_t count = 1) 
     98{ 
     99        //TODO: Apple has problems  
     100        WriteData(pBool, sizeof(bool), count); 
     101} 
     102         
     103//--------------------------------------------------------------------------- 
     104//      Write array of Vector3. 
     105//--------------------------------------------------------------------------- 
     106void Serializer::WriteArray(const Vector3* const pDest, size_t count) 
     107{ 
     108        for(size_t i = 0; i < count; ++i) 
     109        { 
     110                WriteArray(pDest[i].val,3); 
     111        } 
     112} 
     113         
     114//--------------------------------------------------------------------------- 
     115//      Write array of Vector2. 
     116//--------------------------------------------------------------------------- 
     117void Serializer::WriteArray(const Vector2* const pDest, size_t count) 
     118{ 
     119        for(size_t i = 0; i < count; ++i) 
     120        { 
     121                WriteArray(pDest[i].val,2); 
     122        } 
     123} 
     124 
     125//--------------------------------------------------------------------------- 
     126//      Write data. 
     127//--------------------------------------------------------------------------- 
     128void Serializer::WriteData(const void* const buf, size_t size, size_t count) 
     129{ 
     130        size_t wcount = fwrite((void* const)buf, size, count, mFile); 
     131        assert(wcount == count); 
     132        mSize += size*count; 
     133} 
     134 
     135//--------------------------------------------------------------------------- 
     136//      Read data. 
     137//--------------------------------------------------------------------------- 
     138void Serializer::ReadData(void *pDest, size_t size, size_t count) 
     139{ 
     140        size_t rcount = fread(pDest,size,count,mFile); 
     141        assert(rcount == count); 
     142        mSize += size*count; 
     143} 
     144 
     145//--------------------------------------------------------------------------- 
     146//      Read data. 
     147//--------------------------------------------------------------------------- 
     148char * Serializer::ReadData(char *pDest, size_t pDestsize) 
     149{ 
     150        return fgets(pDest, (int)pDestsize, mFile); 
     151} 
     152 
     153//--------------------------------------------------------------------------- 
     154//      Write data. 
     155//--------------------------------------------------------------------------- 
     156void    Serializer::WriteData(const     String  &string) 
     157{ 
     158        fputs(string.c_str(), mFile); 
     159 
     160        // Write terminating newline char 
     161        //fputc('\n', mFile); 
     162 
     163        mSize   +=      string.length(); 
     164} 
     165 
     166//--------------------------------------------------------------------------- 
     167//      Write string data. 
     168//--------------------------------------------------------------------------- 
     169void    Serializer::WriteData(const char        *string) 
     170{ 
     171        fputs(string, mFile); 
     172 
     173        // Write terminating newline char 
     174        //fputc('\n', mFile); 
     175 
     176        mSize   +=      strlen(string) /*+ 1*/; 
     177} 
     178 
     179//--------------------------------------------------------------------------- 
     180//      Read array of booleans. 
     181//--------------------------------------------------------------------------- 
     182void Serializer::ReadArray(bool *pDest, size_t count) 
     183{ 
     184        //TODO:: Apple has problmes with bools 
     185        ReadData(pDest,sizeof(bool), count); 
     186} 
     187 
     188//--------------------------------------------------------------------------- 
     189//      Read array of floats. 
     190//--------------------------------------------------------------------------- 
     191void Serializer::ReadArray(float *pDest, size_t count) 
     192{ 
     193        ReadData(pDest, sizeof(float), count); 
     194        FlipFromLittleEndian(pDest, sizeof(float), count); 
     195} 
     196         
     197//--------------------------------------------------------------------------- 
     198//      Read array of unsigned shots. 
     199//--------------------------------------------------------------------------- 
     200void Serializer::ReadArray(unsigned short *pDest, size_t count) 
     201{ 
     202        ReadData(pDest, sizeof(unsigned short), count); 
     203        FlipFromLittleEndian(pDest, sizeof(unsigned short), count); 
     204} 
     205         
     206//--------------------------------------------------------------------------- 
     207//      Read array of unsigned integers. 
     208//--------------------------------------------------------------------------- 
     209void Serializer::ReadArray(unsigned int *pDest, size_t count) 
     210{ 
     211        ReadData(pDest, sizeof(unsigned int), count); 
     212        FlipFromLittleEndian(pDest, sizeof(unsigned int), count); 
     213} 
     214         
     215//--------------------------------------------------------------------------- 
     216//      Read array of Vector3. 
     217//--------------------------------------------------------------------------- 
     218void Serializer::ReadArray(Vector3 *pDest, size_t count) 
     219{ 
     220        for(size_t i = 0; i < count; ++i) 
     221        { 
     222                ReadArray(pDest[i].val,3); 
     223        } 
     224} 
     225         
     226//--------------------------------------------------------------------------- 
     227//      Read array of Vector2. 
     228//--------------------------------------------------------------------------- 
     229void Serializer::ReadArray(Vector2 *pDest, size_t count) 
     230{ 
     231        for(size_t i = 0; i < count; ++i) 
     232        { 
     233                ReadArray(pDest[i].val,2); 
     234        } 
     235} 
     236 
     237//--------------------------------------------------------------------------- 
     238//      Flip to Little Endian. 
     239//--------------------------------------------------------------------------- 
     240void Serializer::FlipToLittleEndian(void *pData, size_t size, size_t count) 
     241{ 
     242#       if GEO_ENDIAN == GEO_ENDIAN_BIG 
     243        FlipEndian(pData, size, count); 
     244#       endif 
     245} 
     246 
     247//--------------------------------------------------------------------------- 
     248//      Flip from Little Endian. 
     249//--------------------------------------------------------------------------- 
     250void Serializer::FlipFromLittleEndian(void *pData, size_t size, size_t count) 
     251{ 
     252#       if GEO_ENDIAN == GEO_ENDIAN_BIG 
     253        FlipEndian(pData, size, count); 
     254#       endif 
     255} 
     256 
     257//--------------------------------------------------------------------------- 
     258//      Flip Endian. 
     259//--------------------------------------------------------------------------- 
     260void Serializer::FlipEndian(void *pData, size_t size, size_t count) 
     261{ 
     262        for(unsigned int index = 0; index < count; index++) 
     263        { 
     264                FlipEndian((void *)((char*)pData + (index * size)), size); 
     265        } 
     266} 
     267 
     268//--------------------------------------------------------------------------- 
     269//      Flip Endian. 
     270//--------------------------------------------------------------------------- 
     271void Serializer::FlipEndian(void *pData, size_t size) 
     272{ 
     273        char swapByte; 
     274        for(unsigned int byteIndex = 0; byteIndex < size/2; byteIndex++) 
     275        { 
     276                swapByte = *((char *)pData + byteIndex); 
     277                *((char *)pData + byteIndex) = *((char *)pData + size - byteIndex - 1); 
     278                *((char *)pData + size - byteIndex - 1) = swapByte; 
     279        } 
     280} 
     281 
Note: See TracChangeset for help on using the changeset viewer.