b311480e |
1 | // Copyright (c) 1998-1999 Matra Datavision |
973c2be1 |
2 | // Copyright (c) 1999-2014 OPEN CASCADE SAS |
b311480e |
3 | // |
973c2be1 |
4 | // This file is part of Open CASCADE Technology software library. |
b311480e |
5 | // |
973c2be1 |
6 | // This library is free software; you can redistribute it and / or modify it |
7 | // under the terms of the GNU Lesser General Public version 2.1 as published |
8 | // by the Free Software Foundation, with special exception defined in the file |
9 | // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT |
10 | // distribution for complete text of the license and disclaimer of any warranty. |
b311480e |
11 | // |
973c2be1 |
12 | // Alternatively, this file may be used under the terms of Open CASCADE |
13 | // commercial license or contractual agreement. |
b311480e |
14 | |
7fd59977 |
15 | #include <FSD_CmpFile.ixx> |
16 | #include <OSD.hxx> |
17 | |
7fd59977 |
18 | #include <Storage_StreamModeError.hxx> |
19 | #include <Storage_StreamUnknownTypeError.hxx> |
20 | #include <Standard_PCharacter.hxx> |
21 | |
22 | // Propagate the improvement (BUC60808) on all platforms |
23 | // #ifdef WNT |
24 | #define BUC60808 |
25 | // BUC60808 : standard output in MS Visual C++ limites the quantity of figures (digits) |
26 | // in part of number after fixed point. The quantity of figures after fixed point |
27 | // could not be more than 15 when we output double number using standard MS VS output operator '<<'. |
28 | // For example, the maximum double value DBL_MAX = 1.7976931348623157e+308 (see float.h) after |
29 | // cout<<setprecision(17)<<DBL_MAX becomes 1.79769313486232e+308 in stream of output |
30 | // (it could be a file stream). When the number 1.79769313486232e+308 is read from the |
31 | // i/o streame (file, for example) it occurs more than allowed maximum value of double |
32 | // type - 1.7976931348623157e+308. Such value is considered as infinite. When it is written |
33 | // to file (for example) again it is written as 1.#INF. Such value can't be read from file next time. |
34 | //#endif |
35 | |
36 | const Standard_CString MAGICNUMBER = "CMPFILE"; |
7fd59977 |
37 | |
38 | //======================================================================= |
39 | //function : FSD_CmpFile |
40 | //purpose : |
41 | //======================================================================= |
42 | |
43 | FSD_CmpFile::FSD_CmpFile() |
44 | { |
45 | |
46 | } |
47 | |
48 | //======================================================================= |
49 | //function : IsGoodFileType |
50 | //purpose : INFO SECTION |
51 | // write |
52 | //======================================================================= |
53 | |
54 | Storage_Error FSD_CmpFile::IsGoodFileType(const TCollection_AsciiString& aName) |
55 | { |
56 | FSD_CmpFile f; |
57 | Storage_Error s; |
58 | |
59 | s = f.Open(aName,Storage_VSRead); |
60 | |
61 | if (s == Storage_VSOk) { |
62 | TCollection_AsciiString l; |
fb8a7358 |
63 | Standard_Size len = strlen(FSD_CmpFile::MagicNumber()); |
7fd59977 |
64 | |
65 | f.ReadChar(l,len); |
66 | |
67 | f.Close(); |
68 | |
69 | if (strncmp(FSD_CmpFile::MagicNumber(),l.ToCString(),len) != 0) { |
70 | s = Storage_VSFormatError; |
71 | } |
72 | } |
73 | |
74 | return s; |
75 | } |
76 | |
77 | //======================================================================= |
78 | //function : Open |
79 | //purpose : |
80 | //======================================================================= |
81 | |
82 | Storage_Error FSD_CmpFile::Open(const TCollection_AsciiString& aName,const Storage_OpenMode aMode) |
83 | { |
84 | Storage_Error result = Storage_VSOk; |
85 | |
86 | SetName(aName); |
87 | |
88 | if (OpenMode() == Storage_VSNone) { |
89 | |
90 | #if !defined(IRIX) && !defined(DECOSF1) |
91 | if (aMode == Storage_VSRead) { |
92 | myStream.open(aName.ToCString(),ios::in|ios::binary); // ios::nocreate is not portable |
93 | } |
94 | else if (aMode == Storage_VSWrite) { |
95 | myStream.open(aName.ToCString(),ios::out|ios::binary); |
96 | } |
97 | else if (aMode == Storage_VSReadWrite) { |
98 | myStream.open(aName.ToCString(),ios::in|ios::out|ios::binary); |
99 | } |
100 | #else |
101 | if (aMode == Storage_VSRead) { |
102 | myStream.open(aName.ToCString(),ios::in); // ios::nocreate is not portable |
103 | } |
104 | else if (aMode == Storage_VSWrite) { |
105 | myStream.open(aName.ToCString(),ios::out); |
106 | } |
107 | else if (aMode == Storage_VSReadWrite) { |
108 | myStream.open(aName.ToCString(),ios::in|ios::out); |
109 | } |
110 | #endif |
111 | |
112 | if (myStream.fail()) { |
113 | result = Storage_VSOpenError; |
114 | } |
115 | else { |
116 | myStream.precision(17); |
91322f44 |
117 | myStream.imbue (std::locale::classic()); // use always C locale |
7fd59977 |
118 | SetOpenMode(aMode); |
119 | } |
120 | } |
121 | else { |
122 | result = Storage_VSAlreadyOpen; |
123 | } |
124 | return result; |
125 | } |
126 | |
127 | //======================================================================= |
128 | //function : IsEnd |
129 | //purpose : |
130 | //======================================================================= |
131 | |
132 | Standard_Boolean FSD_CmpFile::IsEnd() |
133 | { |
134 | return myStream.eof(); |
135 | } |
136 | |
137 | //======================================================================= |
138 | //function : Close |
139 | //purpose : |
140 | //======================================================================= |
141 | |
142 | Storage_Error FSD_CmpFile::Close() |
143 | { |
144 | Storage_Error result = Storage_VSOk; |
145 | |
146 | if (OpenMode() != Storage_VSNone) { |
147 | myStream.close(); |
148 | SetOpenMode(Storage_VSNone); |
149 | } |
150 | else { |
151 | result = Storage_VSNotOpen; |
152 | } |
153 | |
154 | return result; |
155 | } |
156 | |
157 | //======================================================================= |
158 | //function : MagicNumber |
159 | //purpose : ------------------ PROTECTED |
160 | //======================================================================= |
161 | |
162 | const Standard_CString FSD_CmpFile::MagicNumber() |
163 | { |
164 | return MAGICNUMBER; |
165 | } |
166 | |
167 | //======================================================================= |
168 | //function : FlushEndOfLine |
169 | //purpose : |
170 | //======================================================================= |
171 | |
172 | void FSD_CmpFile::FlushEndOfLine() |
173 | { |
174 | TCollection_AsciiString aDummy; |
175 | ReadLine (aDummy); // flush is nothing more than to read till the line-break |
176 | /* |
177 | static char Buffer[8192]; |
178 | char c; |
179 | Standard_Boolean IsEnd = Standard_False; |
180 | |
181 | while (!IsEnd && !FSD_CmpFile::IsEnd()) { |
182 | Buffer[0] = '\0'; |
183 | myStream.get(Buffer,8192,'\n'); |
184 | |
185 | if (myStream.get(c) && c != '\r' && c != '\n') { |
186 | } |
187 | else { |
188 | IsEnd = Standard_True; |
189 | } |
190 | } |
191 | */ |
192 | } |
193 | |
194 | //======================================================================= |
195 | //function : ReadLine |
196 | //purpose : read from the current position to the end of line. |
197 | //======================================================================= |
198 | |
199 | void FSD_CmpFile::ReadLine(TCollection_AsciiString& buffer) |
200 | { |
201 | char Buffer[8193]; |
202 | //char c; |
203 | Standard_Boolean IsEnd = Standard_False; |
204 | |
205 | buffer.Clear(); |
206 | |
207 | while (!IsEnd && !FSD_CmpFile::IsEnd()) { |
208 | Buffer[0] = '\0'; |
209 | //myStream.get(Buffer,8192,'\n'); |
210 | myStream.getline(Buffer,8192,'\n'); |
fb8a7358 |
211 | for (Standard_Size lv = (strlen(Buffer)- 1); lv > 1 && (Buffer[lv] == '\r' || Buffer[lv] == '\n') ;lv--) { |
7fd59977 |
212 | Buffer[lv] = '\0'; |
213 | } |
214 | |
215 | // if (myStream.get(c) && c != '\r' && c != '\n') { |
216 | // buffer += Buffer; |
217 | // buffer += c; |
218 | // } |
219 | // else { |
220 | buffer += Buffer; |
221 | IsEnd = Standard_True; |
222 | // } |
223 | } |
224 | } |
225 | |
226 | //======================================================================= |
227 | //function : WriteExtendedLine |
228 | //purpose : write from the current position to the end of line. |
229 | //======================================================================= |
230 | |
231 | void FSD_CmpFile::WriteExtendedLine(const TCollection_ExtendedString& buffer) |
232 | { |
233 | #if 0 |
234 | Standard_ExtString extBuffer; |
235 | Standard_Integer i,c,d; |
236 | |
237 | extBuffer = buffer.ToExtString(); |
238 | |
239 | for (i = 0; i < buffer.Length(); i++) { |
240 | c = (extBuffer[i] & 0x0000FF00 ) >> 8 ; |
241 | d = extBuffer[i] & 0x000000FF; |
242 | |
243 | myStream << (char)c << (char)d; |
244 | } |
245 | |
246 | myStream << (char)0 << "\n"; |
247 | #endif |
248 | Standard_ExtString extBuffer; |
249 | Standard_Integer i; |
250 | |
251 | extBuffer = buffer.ToExtString(); |
252 | PutInteger(buffer.Length()); |
253 | for (i = 0; i < buffer.Length(); i++) { |
254 | PutExtCharacter(extBuffer[i]); |
255 | } |
256 | |
257 | myStream << "\n"; |
258 | } |
259 | |
260 | //======================================================================= |
261 | //function : ReadExtendedLine |
262 | //purpose : |
263 | //======================================================================= |
264 | |
265 | void FSD_CmpFile::ReadExtendedLine(TCollection_ExtendedString& buffer) |
266 | { |
267 | Standard_ExtCharacter c; |
268 | Standard_Integer i; |
269 | |
270 | GetInteger(i); |
271 | |
272 | for (i = 0; i < buffer.Length(); i++) { |
273 | GetExtCharacter(c); |
274 | buffer += c; |
275 | } |
276 | |
277 | FlushEndOfLine(); |
7fd59977 |
278 | } |
279 | |
280 | //======================================================================= |
281 | //function : ReadChar |
282 | //purpose : read <rsize> character from the current position. |
283 | //======================================================================= |
284 | |
fb8a7358 |
285 | void FSD_CmpFile::ReadChar(TCollection_AsciiString& buffer, const Standard_Size rsize) |
7fd59977 |
286 | { |
287 | char c; |
fb8a7358 |
288 | Standard_Size ccount = 0; |
7fd59977 |
289 | |
290 | buffer.Clear(); |
291 | |
292 | while (!IsEnd() && (ccount < rsize)) { |
293 | myStream.get(c); |
294 | buffer += c; |
295 | ccount++; |
296 | } |
297 | } |
298 | |
299 | //======================================================================= |
300 | //function : ReadString |
301 | //purpose : read from the first none space character position to the end of line. |
302 | //======================================================================= |
303 | |
304 | void FSD_CmpFile::ReadString(TCollection_AsciiString& buffer) |
305 | { |
306 | char Buffer[8193]; |
307 | char *bpos; |
308 | Standard_Boolean IsEnd = Standard_False,isFirstTime = Standard_True; |
309 | |
310 | buffer.Clear(); |
311 | |
312 | while (!IsEnd && !FSD_CmpFile::IsEnd()) { |
313 | Buffer[0] = '\0'; |
314 | //myStream.get(Buffer,8192,'\n'); |
315 | myStream.getline(Buffer,8192,'\n'); |
fb8a7358 |
316 | for (Standard_Size lv = (strlen(Buffer)- 1); lv > 1 && (Buffer[lv] == '\r' || Buffer[lv] == '\n') ;lv--) { |
7fd59977 |
317 | Buffer[lv] = '\0'; |
318 | } |
319 | bpos = Buffer; |
320 | |
321 | // LeftAdjust |
322 | // |
323 | if (isFirstTime) { |
324 | isFirstTime = Standard_False; |
325 | while (*bpos == '\n' || *bpos == ' ') bpos++; |
326 | } |
327 | // char c; |
328 | // if (myStream.get(c) && c != '\n') { |
329 | // buffer += bpos; |
330 | // buffer += c; |
331 | // } |
332 | // else { |
333 | buffer += bpos; |
334 | IsEnd = Standard_True; |
335 | // } |
336 | } |
337 | } |
338 | |
339 | //======================================================================= |
340 | //function : ReadWord |
341 | //purpose : read from the current position to the next white space or end of line. |
342 | //======================================================================= |
343 | |
344 | void FSD_CmpFile::ReadWord(TCollection_AsciiString& buffer) |
345 | { |
302f96fb |
346 | char c = '\0'; |
7fd59977 |
347 | char b[8193],*tmpb; |
348 | Standard_Boolean IsEnd = Standard_False; |
349 | Standard_Integer i; |
350 | |
351 | tmpb = b; |
352 | memset(b,'\0',8193); |
353 | buffer.Clear(); |
354 | |
355 | while (!IsEnd && !FSD_CmpFile::IsEnd()) { |
356 | myStream.get(c); |
357 | if ((c != ' ') && (c != '\n')) IsEnd = Standard_True; |
358 | } |
359 | |
360 | IsEnd = Standard_False; |
361 | i = 0; |
362 | |
363 | while (!IsEnd && !FSD_CmpFile::IsEnd()) { |
364 | if (i == 8192) { |
365 | buffer += b; |
366 | tmpb = b; |
367 | memset(b,'\0',8193); |
368 | i = 0; |
369 | } |
370 | *tmpb = c; |
371 | tmpb++; i++; |
372 | myStream.get(c); |
373 | if ((c == '\n') || (c == ' ')) IsEnd = Standard_True; |
374 | } |
375 | |
376 | buffer += b; |
377 | } |
378 | |
379 | //======================================================================= |
380 | //function : FindTag |
381 | //purpose : |
382 | //======================================================================= |
383 | |
384 | Storage_Error FSD_CmpFile::FindTag(const Standard_CString aTag) |
385 | { |
386 | TCollection_AsciiString l; |
387 | |
388 | ReadString(l); |
389 | |
390 | while ((strcmp(l.ToCString(),aTag) != 0) && !IsEnd()) { |
391 | ReadString(l); |
392 | } |
393 | |
394 | if (IsEnd()) { |
395 | return Storage_VSSectionNotFound; |
396 | } |
397 | else { |
398 | return Storage_VSOk; |
399 | } |
400 | } |
401 | |
402 | //======================================================================= |
403 | //function : SkipObject |
404 | //purpose : |
405 | //======================================================================= |
406 | |
407 | void FSD_CmpFile::SkipObject() |
408 | { |
409 | FlushEndOfLine(); |
410 | } |
411 | |
412 | //======================================================================= |
413 | //function : PutReference |
414 | //purpose : ---------------------- PUBLIC : PUT |
415 | //======================================================================= |
416 | |
417 | Storage_BaseDriver& FSD_CmpFile::PutReference(const Standard_Integer aValue) |
418 | { |
419 | myStream << aValue << " "; |
420 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
421 | return *this; |
422 | } |
423 | |
424 | //======================================================================= |
425 | //function : PutCharacter |
426 | //purpose : |
427 | //======================================================================= |
428 | |
429 | Storage_BaseDriver& FSD_CmpFile::PutCharacter(const Standard_Character aValue) |
430 | { |
431 | unsigned short i; |
432 | |
433 | i = aValue; |
434 | myStream << i << " "; |
435 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
436 | return *this; |
437 | } |
438 | |
439 | //======================================================================= |
440 | //function : PutExtCharacter |
441 | //purpose : |
442 | //======================================================================= |
443 | |
444 | Storage_BaseDriver& FSD_CmpFile::PutExtCharacter(const Standard_ExtCharacter aValue) |
445 | { |
446 | myStream << aValue << " "; |
447 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
448 | return *this; |
449 | } |
450 | |
451 | //======================================================================= |
452 | //function : PutInteger |
453 | //purpose : |
454 | //======================================================================= |
455 | |
456 | Storage_BaseDriver& FSD_CmpFile::PutInteger(const Standard_Integer aValue) |
457 | { |
458 | myStream << aValue << " "; |
459 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
460 | return *this; |
461 | } |
462 | |
463 | //======================================================================= |
464 | //function : PutBoolean |
465 | //purpose : |
466 | //======================================================================= |
467 | |
468 | Storage_BaseDriver& FSD_CmpFile::PutBoolean(const Standard_Boolean aValue) |
469 | { |
470 | myStream << ((Standard_Integer)aValue) << " "; |
471 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
472 | return *this; |
473 | } |
474 | |
475 | //======================================================================= |
476 | //function : PutReal |
477 | //purpose : |
478 | //======================================================================= |
479 | |
480 | Storage_BaseDriver& FSD_CmpFile::PutReal(const Standard_Real aValue) |
481 | { |
7fd59977 |
482 | myStream << ((Standard_Real)aValue) << " "; |
7fd59977 |
483 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
484 | return *this; |
7fd59977 |
485 | } |
486 | |
487 | //======================================================================= |
488 | //function : PutShortReal |
489 | //purpose : |
490 | //======================================================================= |
491 | |
492 | Storage_BaseDriver& FSD_CmpFile::PutShortReal(const Standard_ShortReal aValue) |
493 | { |
7fd59977 |
494 | myStream << aValue << " "; |
7fd59977 |
495 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
496 | return *this; |
7fd59977 |
497 | } |
498 | |
499 | //======================================================================= |
500 | //function : GetReference |
501 | //purpose : ----------------- PUBLIC : GET |
502 | //======================================================================= |
503 | |
504 | Storage_BaseDriver& FSD_CmpFile::GetReference(Standard_Integer& aValue) |
505 | { |
506 | if (!(myStream >> aValue)) Storage_StreamTypeMismatchError::Raise(); |
507 | |
508 | return *this; |
509 | } |
510 | |
511 | //======================================================================= |
512 | //function : GetCharacter |
513 | //purpose : |
514 | //======================================================================= |
515 | |
516 | Storage_BaseDriver& FSD_CmpFile::GetCharacter(Standard_Character& aValue) |
517 | { |
518 | unsigned short i = 0; |
519 | if (!(myStream >> i)) { |
520 | // SGI : donne une erreur mais a une bonne valeur pour les caracteres ecrits |
521 | // signes (-80 fait ios::badbit, mais la variable i est initialisee) |
522 | // |
523 | if (i == 0) Storage_StreamTypeMismatchError::Raise(); |
524 | myStream.clear(ios::goodbit); |
525 | } |
526 | aValue = (char)i; |
527 | |
528 | return *this; |
529 | } |
530 | |
531 | //======================================================================= |
532 | //function : GetExtCharacter |
533 | //purpose : |
534 | //======================================================================= |
535 | |
536 | Storage_BaseDriver& FSD_CmpFile::GetExtCharacter(Standard_ExtCharacter& aValue) |
537 | { |
538 | if (!(myStream >> aValue)) Storage_StreamTypeMismatchError::Raise(); |
539 | |
540 | return *this; |
541 | } |
542 | |
543 | //======================================================================= |
544 | //function : GetInteger |
545 | //purpose : |
546 | //======================================================================= |
547 | |
548 | Storage_BaseDriver& FSD_CmpFile::GetInteger(Standard_Integer& aValue) |
549 | { |
550 | if (!(myStream >> aValue)) Storage_StreamTypeMismatchError::Raise(); |
551 | |
552 | return *this; |
553 | } |
554 | |
555 | //======================================================================= |
556 | //function : GetBoolean |
557 | //purpose : |
558 | //======================================================================= |
559 | |
560 | Storage_BaseDriver& FSD_CmpFile::GetBoolean(Standard_Boolean& aValue) |
561 | { |
562 | if (!(myStream >> aValue)) Storage_StreamTypeMismatchError::Raise(); |
563 | |
564 | return *this; |
565 | } |
566 | |
567 | //======================================================================= |
568 | //function : GetReal |
569 | //purpose : |
570 | //======================================================================= |
571 | |
572 | Storage_BaseDriver& FSD_CmpFile::GetReal(Standard_Real& aValue) |
573 | { |
574 | #ifdef BUC60808 |
575 | char realbuffer[100]; |
576 | |
577 | realbuffer[0] = '\0'; |
578 | if (!(myStream >> realbuffer)) { |
579 | cerr << "%%%ERROR: read error of double at offset " << myStream.tellg() << endl; |
580 | cerr << "\t buffer is" << realbuffer<< endl; |
581 | Storage_StreamTypeMismatchError::Raise(); |
582 | } |
91322f44 |
583 | if (!OSD::CStringToReal(realbuffer,aValue)) { |
7fd59977 |
584 | cerr << "%%%ERROR: read error of double at offset " << myStream.tellg() << endl; |
585 | cerr << "\t buffer is" << realbuffer<< endl; |
7fd59977 |
586 | Storage_StreamTypeMismatchError::Raise(); |
587 | } |
588 | |
589 | return *this; |
590 | #else |
591 | if (!(myStream >> aValue)) Storage_StreamTypeMismatchError::Raise(); |
592 | |
593 | return *this; |
594 | #endif |
595 | } |
596 | |
597 | //======================================================================= |
598 | //function : GetShortReal |
599 | //purpose : |
600 | //======================================================================= |
601 | |
602 | Storage_BaseDriver& FSD_CmpFile::GetShortReal(Standard_ShortReal& aValue) |
603 | { |
604 | #ifdef BUC60808 |
605 | char realbuffer[100]; |
606 | Standard_Real r = 0.0; |
607 | |
608 | realbuffer[0] = '\0'; |
609 | if (!(myStream >> realbuffer)) Storage_StreamTypeMismatchError::Raise(); |
91322f44 |
610 | if (!OSD::CStringToReal(realbuffer,r)) |
611 | Storage_StreamTypeMismatchError::Raise(); |
7fd59977 |
612 | |
613 | aValue = (Standard_ShortReal)r; |
614 | |
615 | return *this; |
616 | #else |
617 | if (!(myStream >> aValue)) Storage_StreamTypeMismatchError::Raise(); |
618 | return *this; |
619 | #endif |
620 | } |
621 | |
622 | //======================================================================= |
623 | //function : Destroy |
624 | //purpose : |
625 | //======================================================================= |
626 | |
627 | void FSD_CmpFile::Destroy() |
628 | { |
629 | if (OpenMode() != Storage_VSNone) { |
630 | Close(); |
631 | } |
632 | } |
633 | |
634 | //======================================================================= |
635 | //function : BeginWriteInfoSection |
636 | //purpose : -------------------------- INFO : WRITE |
637 | //======================================================================= |
638 | |
639 | Storage_Error FSD_CmpFile::BeginWriteInfoSection() |
640 | { |
641 | myStream << FSD_CmpFile::MagicNumber() << '\n'; |
642 | myStream << "BEGIN_INFO_SECTION\n"; |
643 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
644 | |
645 | return Storage_VSOk; |
646 | } |
647 | |
648 | //======================================================================= |
649 | //function : WriteInfo |
650 | //purpose : |
651 | //======================================================================= |
652 | |
653 | void FSD_CmpFile::WriteInfo(const Standard_Integer nbObj, |
654 | const TCollection_AsciiString& dbVersion, |
655 | const TCollection_AsciiString& date, |
656 | const TCollection_AsciiString& schemaName, |
657 | const TCollection_AsciiString& schemaVersion, |
658 | const TCollection_ExtendedString& appName, |
659 | const TCollection_AsciiString& appVersion, |
660 | const TCollection_ExtendedString& dataType, |
661 | const TColStd_SequenceOfAsciiString& userInfo) |
662 | { |
663 | Standard_Integer i; |
664 | |
665 | myStream << nbObj; |
666 | myStream << "\n"; |
667 | myStream << dbVersion.ToCString() << "\n"; |
668 | myStream << date.ToCString() << "\n"; |
669 | myStream << schemaName.ToCString() << "\n"; |
670 | myStream << schemaVersion.ToCString() << "\n"; |
671 | WriteExtendedLine(appName); |
672 | myStream << appVersion.ToCString() << "\n"; |
673 | WriteExtendedLine(dataType); |
674 | myStream << userInfo.Length() << "\n"; |
675 | |
676 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
677 | |
678 | for (i = 1; i <= userInfo.Length(); i++) { |
679 | myStream << userInfo.Value(i).ToCString() << "\n"; |
680 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
681 | } |
682 | } |
683 | |
684 | //======================================================================= |
685 | //function : EndWriteInfoSection |
686 | //purpose : read |
687 | //======================================================================= |
688 | |
689 | Storage_Error FSD_CmpFile::EndWriteInfoSection() |
690 | { |
691 | myStream << "END_INFO_SECTION\n"; |
692 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
693 | return Storage_VSOk; |
694 | } |
695 | |
696 | //======================================================================= |
697 | //function : BeginReadInfoSection |
698 | //purpose : |
699 | //======================================================================= |
700 | |
701 | Storage_Error FSD_CmpFile::BeginReadInfoSection() |
702 | { |
703 | Storage_Error s; |
704 | TCollection_AsciiString l; |
fb8a7358 |
705 | Standard_Size len = strlen(FSD_CmpFile::MagicNumber()); |
7fd59977 |
706 | |
707 | ReadChar(l,len); |
708 | |
709 | if (strncmp(FSD_CmpFile::MagicNumber(),l.ToCString(),len) != 0) { |
710 | s = Storage_VSFormatError; |
711 | } |
712 | else { |
713 | s = FindTag("BEGIN_INFO_SECTION"); |
714 | } |
715 | |
716 | return s; |
717 | } |
718 | |
719 | //======================================================================= |
720 | //function : ReadInfo |
721 | //purpose : ------------------- INFO : READ |
722 | //======================================================================= |
723 | |
724 | void FSD_CmpFile::ReadInfo(Standard_Integer& nbObj, |
725 | TCollection_AsciiString& dbVersion, |
726 | TCollection_AsciiString& date, |
727 | TCollection_AsciiString& schemaName, |
728 | TCollection_AsciiString& schemaVersion, |
729 | TCollection_ExtendedString& appName, |
730 | TCollection_AsciiString& appVersion, |
731 | TCollection_ExtendedString& dataType, |
732 | TColStd_SequenceOfAsciiString& userInfo) |
733 | { |
734 | if (!(myStream >> nbObj)) Storage_StreamTypeMismatchError::Raise(); |
735 | |
736 | FlushEndOfLine(); |
737 | |
738 | ReadLine(dbVersion); |
739 | ReadLine(date); |
740 | ReadLine(schemaName); |
741 | ReadLine(schemaVersion); |
742 | ReadExtendedLine(appName); |
743 | ReadLine(appVersion); |
744 | ReadExtendedLine(dataType); |
745 | |
746 | Standard_Integer i,len = 0; |
747 | |
748 | if (!(myStream >> len)) Storage_StreamTypeMismatchError::Raise(); |
749 | |
750 | FlushEndOfLine(); |
751 | |
752 | TCollection_AsciiString line; |
753 | |
754 | for (i = 1; i <= len && !IsEnd(); i++) { |
755 | ReadLine(line); |
756 | userInfo.Append(line); |
757 | line.Clear(); |
758 | } |
759 | } |
760 | |
761 | //======================================================================= |
762 | //function : EndReadInfoSection |
763 | //purpose : COMMENTS SECTION |
764 | // write |
765 | //======================================================================= |
766 | |
767 | Storage_Error FSD_CmpFile::EndReadInfoSection() |
768 | { |
769 | return FindTag("END_INFO_SECTION"); |
770 | } |
771 | |
772 | //======================================================================= |
773 | //function : BeginWriteCommentSection |
774 | //purpose : ---------------- COMMENTS : WRITE |
775 | //======================================================================= |
776 | |
777 | Storage_Error FSD_CmpFile::BeginWriteCommentSection() |
778 | { |
779 | myStream << "BEGIN_COMMENT_SECTION\n"; |
780 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
781 | return Storage_VSOk; |
782 | } |
783 | |
784 | //======================================================================= |
785 | //function : WriteComment |
786 | //purpose : |
787 | //======================================================================= |
788 | |
789 | void FSD_CmpFile::WriteComment(const TColStd_SequenceOfExtendedString& aCom) |
790 | { |
791 | Standard_Integer i,aSize; |
792 | |
793 | aSize = aCom.Length(); |
794 | myStream << aSize << "\n"; |
795 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
796 | |
797 | for (i = 1; i <= aSize; i++) { |
798 | WriteExtendedLine(aCom.Value(i)); |
799 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
800 | } |
801 | } |
802 | |
803 | //======================================================================= |
804 | //function : EndWriteCommentSection |
805 | //purpose : read |
806 | //======================================================================= |
807 | |
808 | Storage_Error FSD_CmpFile::EndWriteCommentSection() |
809 | { |
810 | myStream << "END_COMMENT_SECTION\n"; |
811 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
812 | return Storage_VSOk; |
813 | } |
814 | |
815 | //======================================================================= |
816 | //function : BeginReadCommentSection |
817 | //purpose : ---------------- COMMENTS : READ |
818 | //======================================================================= |
819 | |
820 | Storage_Error FSD_CmpFile::BeginReadCommentSection() |
821 | { |
822 | return FindTag("BEGIN_COMMENT_SECTION"); |
823 | } |
824 | |
825 | //======================================================================= |
826 | //function : ReadComment |
827 | //purpose : |
828 | //======================================================================= |
829 | |
830 | void FSD_CmpFile::ReadComment(TColStd_SequenceOfExtendedString& aCom) |
831 | { |
832 | TCollection_ExtendedString line; |
833 | Standard_Integer len,i; |
834 | |
835 | if (!(myStream >> len)) Storage_StreamTypeMismatchError::Raise(); |
836 | |
837 | FlushEndOfLine(); |
838 | |
839 | for (i = 1; i <= len && !IsEnd(); i++) { |
840 | ReadExtendedLine(line); |
841 | aCom.Append(line); |
842 | line.Clear(); |
843 | } |
844 | } |
845 | |
846 | //======================================================================= |
847 | //function : EndReadCommentSection |
848 | //purpose : |
849 | //======================================================================= |
850 | |
851 | Storage_Error FSD_CmpFile::EndReadCommentSection() |
852 | { |
853 | return FindTag("END_COMMENT_SECTION"); |
854 | } |
855 | |
856 | //======================================================================= |
857 | //function : BeginWriteTypeSection |
858 | //purpose : --------------- TYPE : WRITE |
859 | //======================================================================= |
860 | |
861 | Storage_Error FSD_CmpFile::BeginWriteTypeSection() |
862 | { |
863 | myStream << "BEGIN_TYPE_SECTION\n"; |
864 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
865 | return Storage_VSOk; |
866 | } |
867 | |
868 | //======================================================================= |
869 | //function : SetTypeSectionSize |
870 | //purpose : |
871 | //======================================================================= |
872 | |
873 | void FSD_CmpFile::SetTypeSectionSize(const Standard_Integer aSize) |
874 | { |
875 | myStream << aSize << "\n"; |
876 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
877 | } |
878 | |
879 | //======================================================================= |
880 | //function : WriteTypeInformations |
881 | //purpose : |
882 | //======================================================================= |
883 | |
884 | void FSD_CmpFile::WriteTypeInformations(const Standard_Integer typeNum, |
885 | const TCollection_AsciiString& typeName) |
886 | { |
887 | myStream << typeNum << " " << typeName.ToCString() << "\n"; |
888 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
889 | } |
890 | |
891 | //======================================================================= |
892 | //function : EndWriteTypeSection |
893 | //purpose : read |
894 | //======================================================================= |
895 | |
896 | Storage_Error FSD_CmpFile::EndWriteTypeSection() |
897 | { |
898 | myStream << "END_TYPE_SECTION\n"; |
899 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
900 | return Storage_VSOk; |
901 | } |
902 | |
903 | //======================================================================= |
904 | //function : BeginReadTypeSection |
905 | //purpose : ------------------- TYPE : READ |
906 | //======================================================================= |
907 | |
908 | Storage_Error FSD_CmpFile::BeginReadTypeSection() |
909 | { |
910 | return FindTag("BEGIN_TYPE_SECTION"); |
911 | } |
912 | |
913 | //======================================================================= |
914 | //function : TypeSectionSize |
915 | //purpose : |
916 | //======================================================================= |
917 | |
918 | Standard_Integer FSD_CmpFile::TypeSectionSize() |
919 | { |
920 | Standard_Integer i; |
921 | |
922 | if (!(myStream >> i)) Storage_StreamTypeMismatchError::Raise(); |
923 | |
924 | FlushEndOfLine(); |
925 | |
926 | return i; |
927 | } |
928 | |
929 | //======================================================================= |
930 | //function : ReadTypeInformations |
931 | //purpose : |
932 | //======================================================================= |
933 | |
934 | void FSD_CmpFile::ReadTypeInformations(Standard_Integer& typeNum, |
935 | TCollection_AsciiString& typeName) |
936 | { |
937 | if (!(myStream >> typeNum)) Storage_StreamTypeMismatchError::Raise(); |
938 | if (!(myStream >> typeName)) Storage_StreamTypeMismatchError::Raise(); |
939 | FlushEndOfLine(); |
940 | } |
941 | |
942 | //======================================================================= |
943 | //function : EndReadTypeSection |
944 | //purpose : ROOT SECTION |
945 | // write |
946 | //======================================================================= |
947 | |
948 | Storage_Error FSD_CmpFile::EndReadTypeSection() |
949 | { |
950 | return FindTag("END_TYPE_SECTION"); |
951 | } |
952 | |
953 | //======================================================================= |
954 | //function : BeginWriteRootSection |
955 | //purpose : -------------------- ROOT : WRITE |
956 | //======================================================================= |
957 | |
958 | Storage_Error FSD_CmpFile::BeginWriteRootSection() |
959 | { |
960 | myStream << "BEGIN_ROOT_SECTION\n"; |
961 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
962 | return Storage_VSOk; |
963 | } |
964 | |
965 | //======================================================================= |
966 | //function : SetRootSectionSize |
967 | //purpose : |
968 | //======================================================================= |
969 | |
970 | void FSD_CmpFile::SetRootSectionSize(const Standard_Integer aSize) |
971 | { |
972 | myStream << aSize << "\n"; |
973 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
974 | } |
975 | |
976 | //======================================================================= |
977 | //function : WriteRoot |
978 | //purpose : |
979 | //======================================================================= |
980 | |
981 | void FSD_CmpFile::WriteRoot(const TCollection_AsciiString& rootName, const Standard_Integer aRef, const TCollection_AsciiString& rootType) |
982 | { |
983 | myStream << aRef << " " << rootName.ToCString() << " " << rootType.ToCString() << "\n"; |
984 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
985 | } |
986 | |
987 | //======================================================================= |
988 | //function : EndWriteRootSection |
989 | //purpose : read |
990 | //======================================================================= |
991 | |
992 | Storage_Error FSD_CmpFile::EndWriteRootSection() |
993 | { |
994 | myStream << "END_ROOT_SECTION\n"; |
995 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
996 | return Storage_VSOk; |
997 | } |
998 | |
999 | //======================================================================= |
1000 | //function : BeginReadRootSection |
1001 | //purpose : ----------------------- ROOT : READ |
1002 | //======================================================================= |
1003 | |
1004 | Storage_Error FSD_CmpFile::BeginReadRootSection() |
1005 | { |
1006 | return FindTag("BEGIN_ROOT_SECTION"); |
1007 | } |
1008 | |
1009 | //======================================================================= |
1010 | //function : RootSectionSize |
1011 | //purpose : |
1012 | //======================================================================= |
1013 | |
1014 | Standard_Integer FSD_CmpFile::RootSectionSize() |
1015 | { |
1016 | Standard_Integer i; |
1017 | |
1018 | if (!(myStream >> i)) Storage_StreamTypeMismatchError::Raise(); |
1019 | |
1020 | FlushEndOfLine(); |
1021 | |
1022 | return i; |
1023 | } |
1024 | |
1025 | //======================================================================= |
1026 | //function : ReadRoot |
1027 | //purpose : |
1028 | //======================================================================= |
1029 | |
1030 | void FSD_CmpFile::ReadRoot(TCollection_AsciiString& rootName, Standard_Integer& aRef,TCollection_AsciiString& rootType) |
1031 | { |
1032 | if (!(myStream >> aRef)) Storage_StreamTypeMismatchError::Raise(); |
1033 | ReadWord(rootName); |
1034 | ReadWord(rootType); |
1035 | } |
1036 | |
1037 | //======================================================================= |
1038 | //function : EndReadRootSection |
1039 | //purpose : REF SECTION |
1040 | // write |
1041 | //======================================================================= |
1042 | |
1043 | Storage_Error FSD_CmpFile::EndReadRootSection() |
1044 | { |
1045 | return FindTag("END_ROOT_SECTION"); |
1046 | } |
1047 | |
1048 | //======================================================================= |
1049 | //function : BeginWriteRefSection |
1050 | //purpose : -------------------------- REF : WRITE |
1051 | //======================================================================= |
1052 | |
1053 | Storage_Error FSD_CmpFile::BeginWriteRefSection() |
1054 | { |
1055 | myStream << "BEGIN_REF_SECTION\n"; |
1056 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
1057 | return Storage_VSOk; |
1058 | } |
1059 | |
1060 | //======================================================================= |
1061 | //function : SetRefSectionSize |
1062 | //purpose : |
1063 | //======================================================================= |
1064 | |
1065 | void FSD_CmpFile::SetRefSectionSize(const Standard_Integer aSize) |
1066 | { |
1067 | myStream << aSize << "\n"; |
1068 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
1069 | } |
1070 | |
1071 | //======================================================================= |
1072 | //function : WriteReferenceType |
1073 | //purpose : |
1074 | //======================================================================= |
1075 | |
1076 | void FSD_CmpFile::WriteReferenceType(const Standard_Integer reference, |
1077 | const Standard_Integer typeNum) |
1078 | { |
1079 | myStream << reference << " " << typeNum << "\n"; |
1080 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
1081 | } |
1082 | |
1083 | //======================================================================= |
1084 | //function : EndWriteRefSection |
1085 | //purpose : read |
1086 | //======================================================================= |
1087 | |
1088 | Storage_Error FSD_CmpFile::EndWriteRefSection() |
1089 | { |
1090 | myStream << "END_REF_SECTION\n"; |
1091 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
1092 | return Storage_VSOk; |
1093 | } |
1094 | |
1095 | //======================================================================= |
1096 | //function : BeginReadRefSection |
1097 | //purpose : ----------------------- REF : READ |
1098 | //======================================================================= |
1099 | |
1100 | Storage_Error FSD_CmpFile::BeginReadRefSection() |
1101 | { |
1102 | return FindTag("BEGIN_REF_SECTION"); |
1103 | } |
1104 | |
1105 | //======================================================================= |
1106 | //function : RefSectionSize |
1107 | //purpose : |
1108 | //======================================================================= |
1109 | |
1110 | Standard_Integer FSD_CmpFile::RefSectionSize() |
1111 | { |
1112 | Standard_Integer i; |
1113 | |
1114 | if (!(myStream >> i)) Storage_StreamTypeMismatchError::Raise(); |
1115 | FlushEndOfLine(); |
1116 | |
1117 | return i; |
1118 | } |
1119 | |
1120 | //======================================================================= |
1121 | //function : ReadReferenceType |
1122 | //purpose : |
1123 | //======================================================================= |
1124 | |
1125 | void FSD_CmpFile::ReadReferenceType(Standard_Integer& reference, |
1126 | Standard_Integer& typeNum) |
1127 | { |
1128 | if (!(myStream >> reference)) Storage_StreamTypeMismatchError::Raise(); |
1129 | if (!(myStream >> typeNum)) Storage_StreamTypeMismatchError::Raise(); |
1130 | FlushEndOfLine(); |
1131 | } |
1132 | |
1133 | //======================================================================= |
1134 | //function : EndReadRefSection |
1135 | //purpose : DATA SECTION |
1136 | // write |
1137 | //======================================================================= |
1138 | |
1139 | Storage_Error FSD_CmpFile::EndReadRefSection() |
1140 | { |
1141 | return FindTag("END_REF_SECTION"); |
1142 | } |
1143 | |
1144 | //======================================================================= |
1145 | //function : BeginWriteDataSection |
1146 | //purpose : -------------------- DATA : WRITE |
1147 | //======================================================================= |
1148 | |
1149 | Storage_Error FSD_CmpFile::BeginWriteDataSection() |
1150 | { |
1151 | myStream << "BEGIN_DATA_SECTION"; |
1152 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
1153 | return Storage_VSOk; |
1154 | } |
1155 | |
1156 | //======================================================================= |
1157 | //function : WritePersistentObjectHeader |
1158 | //purpose : |
1159 | //======================================================================= |
1160 | |
1161 | void FSD_CmpFile::WritePersistentObjectHeader(const Standard_Integer aRef, |
1162 | const Standard_Integer aType) |
1163 | { |
1164 | myStream << "\n#" << aRef << "%" << aType << " "; |
1165 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
1166 | } |
1167 | |
1168 | //======================================================================= |
1169 | //function : BeginWritePersistentObjectData |
1170 | //purpose : |
1171 | //======================================================================= |
1172 | |
1173 | void FSD_CmpFile::BeginWritePersistentObjectData() |
1174 | { |
1175 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
1176 | } |
1177 | |
1178 | //======================================================================= |
1179 | //function : BeginWriteObjectData |
1180 | //purpose : |
1181 | //======================================================================= |
1182 | |
1183 | void FSD_CmpFile::BeginWriteObjectData() |
1184 | { |
1185 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
1186 | } |
1187 | |
1188 | //======================================================================= |
1189 | //function : EndWriteObjectData |
1190 | //purpose : |
1191 | //======================================================================= |
1192 | |
1193 | void FSD_CmpFile::EndWriteObjectData() |
1194 | { |
1195 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
1196 | } |
1197 | |
1198 | //======================================================================= |
1199 | //function : EndWritePersistentObjectData |
1200 | //purpose : |
1201 | //======================================================================= |
1202 | |
1203 | void FSD_CmpFile::EndWritePersistentObjectData() |
1204 | { |
1205 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
1206 | } |
1207 | |
1208 | //======================================================================= |
1209 | //function : EndWriteDataSection |
1210 | //purpose : read |
1211 | //======================================================================= |
1212 | |
1213 | Storage_Error FSD_CmpFile::EndWriteDataSection() |
1214 | { |
1215 | myStream << "\nEND_DATA_SECTION\n"; |
1216 | if (myStream.bad()) Storage_StreamWriteError::Raise(); |
1217 | return Storage_VSOk; |
1218 | } |
1219 | |
1220 | //======================================================================= |
1221 | //function : BeginReadDataSection |
1222 | //purpose : ---------------------- DATA : READ |
1223 | //======================================================================= |
1224 | |
1225 | Storage_Error FSD_CmpFile::BeginReadDataSection() |
1226 | { |
1227 | return FindTag("BEGIN_DATA_SECTION"); |
1228 | } |
1229 | |
1230 | //======================================================================= |
1231 | //function : ReadPersistentObjectHeader |
1232 | //purpose : |
1233 | //======================================================================= |
1234 | |
1235 | void FSD_CmpFile::ReadPersistentObjectHeader(Standard_Integer& aRef, |
1236 | Standard_Integer& aType) |
1237 | { |
1238 | char c; |
1239 | |
1240 | myStream.get(c); |
1241 | |
1242 | while (c != '#') { |
1243 | if (IsEnd() || (c != ' ') || (c == '\r')|| (c == '\n')) { |
1244 | Storage_StreamFormatError::Raise(); |
1245 | } |
1246 | myStream.get(c); |
1247 | } |
1248 | |
1249 | if (!(myStream >> aRef)) Storage_StreamTypeMismatchError::Raise(); |
1250 | |
1251 | myStream.get(c); |
1252 | |
1253 | while (c != '%') { |
1254 | if (IsEnd() || (c != ' ') || (c == '\r')|| (c == '\n')) { |
1255 | Storage_StreamFormatError::Raise(); |
1256 | } |
1257 | myStream.get(c); |
1258 | } |
1259 | |
1260 | if (!(myStream >> aType)) Storage_StreamTypeMismatchError::Raise(); |
1261 | // cout << "REF:" << aRef << " TYPE:"<< aType << endl; |
1262 | } |
1263 | |
1264 | //======================================================================= |
1265 | //function : BeginReadPersistentObjectData |
1266 | //purpose : |
1267 | //======================================================================= |
1268 | |
1269 | void FSD_CmpFile::BeginReadPersistentObjectData() |
1270 | { |
1271 | //cout << "BeginReadPersistentObjectData" << endl; |
1272 | } |
1273 | |
1274 | //======================================================================= |
1275 | //function : BeginReadObjectData |
1276 | //purpose : |
1277 | //======================================================================= |
1278 | |
1279 | void FSD_CmpFile::BeginReadObjectData() |
1280 | { |
1281 | // cout << "BeginReadObjectData" << endl; |
1282 | } |
1283 | |
1284 | //======================================================================= |
1285 | //function : EndReadObjectData |
1286 | //purpose : |
1287 | //======================================================================= |
1288 | |
1289 | void FSD_CmpFile::EndReadObjectData() |
1290 | { |
1291 | // cout << "EndReadObjectData" << endl; |
1292 | } |
1293 | |
1294 | //======================================================================= |
1295 | //function : EndReadPersistentObjectData |
1296 | //purpose : |
1297 | //======================================================================= |
1298 | |
1299 | void FSD_CmpFile::EndReadPersistentObjectData() |
1300 | { |
1301 | char c; |
1302 | |
1303 | myStream.get(c); |
1304 | while (c != '\n' && (c != '\r')) { |
1305 | if (IsEnd() || (c != ' ')) { |
1306 | Storage_StreamFormatError::Raise(); |
1307 | } |
1308 | myStream.get(c); |
1309 | } |
1310 | if (c == '\r') { |
1311 | myStream.get(c); |
1312 | } |
1313 | // cout << "EndReadPersistentObjectData" << endl; |
1314 | } |
1315 | |
1316 | //======================================================================= |
1317 | //function : EndReadDataSection |
1318 | //purpose : |
1319 | //======================================================================= |
1320 | |
1321 | Storage_Error FSD_CmpFile::EndReadDataSection() |
1322 | { |
1323 | return FindTag("END_DATA_SECTION"); |
1324 | } |
1325 | |
1326 | //======================================================================= |
1327 | //function : Tell |
1328 | //purpose : return position in the file. Return -1 upon error. |
1329 | //======================================================================= |
1330 | |
1331 | Storage_Position FSD_CmpFile::Tell() |
1332 | { |
1333 | switch (OpenMode()) { |
1334 | case Storage_VSRead: |
1335 | return (Storage_Position) myStream.tellp(); |
1336 | case Storage_VSWrite: |
1337 | return (Storage_Position) myStream.tellg(); |
1338 | case Storage_VSReadWrite: { |
1339 | Storage_Position aPosR = (Storage_Position) myStream.tellp(); |
1340 | Storage_Position aPosW = (Storage_Position) myStream.tellg(); |
1341 | if (aPosR < aPosW) |
1342 | return aPosW; |
1343 | else |
1344 | return aPosR; |
1345 | } |
1346 | default: return -1; |
1347 | } |
7fd59977 |
1348 | } |