source: GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoSerializer.cpp @ 980

Revision 980, 6.5 KB checked in by gumbau, 18 years ago (diff)
Line 
1#include "GeoSerializer.h"
2
3
4namespace 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);
47#       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);
63#       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);
79#       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
Note: See TracBrowser for help on using the repository browser.