GeoTessCPP 2.6.1 Software to facilitate storage and retrieval of 3D information about the Earth.

Loading...
Searching...
No Matches
IFStreamBinary.h
Go to the documentation of this file.
1//- ****************************************************************************
2//-
3//- Copyright 2009 Sandia Corporation. Under the terms of Contract
4//- DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government
5//- retains certain rights in this software.
6//-
7//- BSD Open Source License.
8//- All rights reserved.
9//-
10//- Redistribution and use in source and binary forms, with or without
11//- modification, are permitted provided that the following conditions are met:
12//-
13//- * Redistributions of source code must retain the above copyright notice,
14//- this list of conditions and the following disclaimer.
15//- * Redistributions in binary form must reproduce the above copyright
16//- notice, this list of conditions and the following disclaimer in the
17//- documentation and/or other materials provided with the distribution.
18//- * Neither the name of Sandia National Laboratories nor the names of its
19//- contributors may be used to endorse or promote products derived from
20//- this software without specific prior written permission.
21//-
22//- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
23//- AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24//- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25//- ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
26//- LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
27//- CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
28//- SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
29//- INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
30//- CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
31//- ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32//- POSSIBILITY OF SUCH DAMAGE.
33//-
34//- ****************************************************************************
35
36#ifndef IFSTREAMBINARY_OBJECT_H
37#define IFSTREAMBINARY_OBJECT_H
38
39// **** _SYSTEM INCLUDES_ ******************************************************
40
41#include <iostream>
42#include <string>
43#include <cstring>
44#include <fstream>
45#include <vector>
46#include <sstream>
47
48// use standard library objects
49 using namespace std;
50
51// **** _LOCAL INCLUDES_ *******************************************************
52
53#include "CPPUtils.h"
54#include "GeoTessUtils.h"
55#include "GeoTessException.h"
56
57// **** _BEGIN GEOTESS NAMESPACE_ **********************************************
58
59 namespace geotess {
60
61// **** _FORWARD REFERENCES_ ***************************************************
62
63// **** _CLASS DEFINITION_ *****************************************************
64
79 class GEOTESS_EXP_IMP IFStreamBinary
80{
81 protected:
82
86 string* bData;
87
91 int bDataPos;
92
96 int bSize;
97
102 bool bAlign;
103
111 bool bReverse;
112
118 bool bOwnStr;
119
120 string bFileName;
121
122 int bMemIncr;
123
128 void align2Byte()
129 {
130 int sm = bDataPos % CPPUtils::SSHT;
131 if (sm && bAlign) bDataPos += CPPUtils::SSHT - sm;
132 }
133
138 void align4Byte()
139 {
140 int sm = bDataPos % CPPUtils::SINT;
141 if (sm && bAlign) bDataPos += CPPUtils::SINT - sm;
142 }
143
148 void align8Byte()
149 {
150 int sm = bDataPos % CPPUtils::SDBL;
151 if (sm && bAlign) bDataPos += CPPUtils::SDBL - sm;
152 }
153
158 void checkBufferSize(int sincr)
159 {
160 if (bDataPos + sincr > (int) bData->size())
161 {
162 if (sincr + bData->size() > bData->capacity())
163 bData->reserve(bData->capacity() + bMemIncr);
164 bData->append(bDataPos + sincr - bData->size(), ' ');
165 }
166 }
167
168 /*
169 * Reverses each s-byte element of array a containing n elements
170 * (s*n bytes). The element size s must be 2, 4, or 8.
171 */
172 static void reverseBOArray(int n, char* a, int s);
173
174 /*
175 * Reverses the byte order of each element of a where a is an array of n
176 * 2, 4, or 8 byte elements. Used to convert between big-and
177 * little-endian formats.
178 */
179 static void reverseBO2Array(int n, char* a);
180 static void reverseBO4Array(int n, char* a);
181 static void reverseBO8Array(int n, char* a);
182
183 /*
184 * Reverses the byte order of d, where d is a 2, 4, or 8 byte array. Used
185 * to convert between big-and little-endian formats.
186 */
187 static void reverseBO2(char* d);
188 static void reverseBO4(char* d);
189 static void reverseBO8(char* d);
190
191 public:
192
196 IFStreamBinary();
197
201 IFStreamBinary(bool align);
202
207 IFStreamBinary(const string& filename);
208
213 IFStreamBinary(const string& filename, int num_bytes);
214
219 IFStreamBinary(string* str);
220
224 IFStreamBinary(const IFStreamBinary& db);
225
229 virtual ~IFStreamBinary();
230
234 IFStreamBinary& operator=(const IFStreamBinary& db);
235
239 void dumpBuffer();
240
244 static bool exists(const string& filename);
245
249 void writeToFile(const string& filename);
250
254 void writeToFile(ofstream& ofs);
255
259 void readFromFile(const string& filename);
260
264 void readFromFile(const string& filename, int num_bytes);
265
270// void readFromFile(ifstream& ifs, streampos file_pos,
271// int num_bytes);
272
276 void readFromFile(ifstream& ifs, int num_bytes);
277
281 const string& getFileName() const { return bFileName; }
282
286 void clear()
287 {
288 (*bData) = "";
289 bDataPos = 0;
290 bSize = 0;
291 }
292
297 void setMemoryCapacityIncrement(int mci)
298 {
299 if (mci > 0) bMemIncr = mci;
300 }
301
310 string readString();
311 void readString(string& s);
312 void readCharArray(string& s, int num_chars);
313 void readCharArray(char* array, int num_chars);
314 void readType(string& s);
315 void readTypeArray(string& array, int num_chars);
316
324 bool readBool();
325 bool readBool(int pos);
326 void readBoolArray(bool* array, int num_bools);
327 void readType(bool& b);
328 void readTypeArray(bool* array, int num_bools);
329
337 byte readByte();
338 byte readByte(int pos);
339 void readByteArray(byte* array, int num_bs);
340 void readType(byte& b);
341 void readTypeArray(byte* array, int num_bs);
342
352 short readShort();
353 short readShortNC();
354 short readShort(int pos);
355 void readShortArray(short* array, int num_shorts);
356 void readType(short& s);
357 void readTypeArray(short* array, int num_shorts);
358
368 int readInt();
369 int readIntNC();
370 int readInt(int pos);
371 void readIntArray(int* array, int num_ints);
372 void readType(int& i);
373 void readTypeArray(int* array, int num_ints);
374
384 LONG_INT readLong();
385 LONG_INT readLongNC();
386 LONG_INT readLong(int pos);
387 void readLongArray(LONG_INT* array, int num_longs);
388 void readType(LONG_INT& l);
389 void readTypeArray(LONG_INT* array, int num_longs);
390
400 float readFloat();
401 float readFloatNC();
402 float readFloat(int pos);
403 void readFloatArray(float* array, int num_floats);
404 void readType(float& f);
405 void readTypeArray(float* array, int num_floats);
406
416 double readDouble();
417 double readDoubleNC();
418 double readDouble(int pos);
419 void readDoubleArray(double* array, int num_doubles);
420 void readType(double& d);
421 void readTypeArray(double* array, int num_doubles);
422
431 void writeString(const string& str);
432 void writeString(const char* char_string);
433 void writeCharArray(const char* array, int num_chars);
434 void writeType(const string& str);
435 void writeType(const char* char_string);
436
447 void writeBool(bool b);
448 void writeBoolNC(bool b);
449 void writeBool(bool b, int pos);
450 void writeBoolArray(const bool* array, int num_bools);
451 void writeType(bool b);
452 void writeTypeArray(const bool* array, int num_bools);
453
464 void writeByte(byte b);
465 void writeByteNC(byte b);
466 void writeByte(byte b, int pos);
467 void writeByteArray(const byte* array, int num_bytes);
468 void writeType(byte b);
469 void writeTypeArray(const byte* array, int num_bytes);
470
482 void writeShort(short i);
483 void writeShortNC(short i);
484 void writeShort(short i, int pos);
485 void writeShortArray(const short* array, int num_ints);
486 void writeType(short i);
487 void writeTypeArray(const short* array, int num_ints);
488
500 void writeInt(int i);
501 void writeIntNC(int i);
502 void writeInt(int i, int pos);
503 void writeIntArray(const int* array, int num_ints);
504 void writeType(int i);
505 void writeTypeArray(const int* array, int num_ints);
506
518 void writeLong(LONG_INT l);
519 void writeLongNC(LONG_INT l);
520 void writeLong(LONG_INT l, int pos);
521 void writeLongArray(const LONG_INT* array, int num_longs);
522 void writeType(LONG_INT l);
523 void writeTypeArray(const LONG_INT* array, int num_longs);
524
536 void writeFloat(float f);
537 void writeFloatNC(float f);
538 void writeFloat(float f, int pos);
539 void writeFloatArray(const float* array, int num_floats);
540 void writeType(float f);
541 void writeTypeArray(const float* array, int num_floats);
542
554 void writeDouble(double d);
555 void writeDoubleNC(double d);
556 void writeDouble(double d, int pos);
557 void writeDoubleArray(const double* array, int num_doubles);
558 void writeType(double d);
559 void writeTypeArray(const double* array, int num_doubles);
560
561 /*
562 * Return class name.
563 */
564 static string className()
565 { return "IFStreamBinary"; }
566
567 /*
568 * Return class size.
569 */
570 static int classSize()
571 { return (int) sizeof(IFStreamBinary); }
572
577 void reSize(int spc)
578 { bData->resize(spc); }
579
583 void reserve(int sze)
584 { bData->reserve(sze); }
585
589 int size()
590 {
591 if (bDataPos > bSize) bSize = bDataPos;
592 return bSize;
593 }
594
598 void resetPos()
599 {
600 if (bDataPos > bSize) bSize = bDataPos;
601 bDataPos = 0;
602 }
603
607 void setPosToEnd()
608 {
609 if (bDataPos > bSize) bSize = bDataPos;
610 bDataPos = bSize;
611 }
612
616 int getPos() const
617 { return bDataPos; }
618
622 void incrementPos(int increment = 1)
623 { bDataPos += increment; }
624
628 void decrementPos(int decrement = 1)
629 { bDataPos -= decrement; }
630
634 const string& getData() const
635 { return *bData; }
636
640 int getCapacity() const
641 { return (int) bData->capacity(); }
642
647 char* getPosPointer()
648 { return getPosPointer(bDataPos); }
649
653 char* getPosPointer(int pos)
654 {
655 char* p = &(*bData)[pos];
656 return p;
657 }
658
662 void setByteOrderReverse(bool bor)
663 { bReverse = bor; }
664
668 void byteOrderReverseOn()
669 { bReverse = true; }
670
674 void byteOrderReverseOff()
675 { bReverse = false; }
676
681 bool isByteOrderReversalOn() const
682 { return bReverse; }
683
687 void setBoundaryAlignment(bool align)
688 { bAlign = align; }
689
693 void boundaryAlignmentOn()
694 { bAlign = true; }
695
699 void boundaryAlignmentOff()
700 { bAlign = false; }
701
706 bool isBoundaryAlignmentOn() const
707 { return bAlign; }
708
709}; // end class IFStreamBinary
710
711//************* Read Strings **************************************************
712
716 inline string IFStreamBinary::readString()
717{
718 string s;
719 readString(s);
720 return s;
721}
722
726 inline void IFStreamBinary::readString(string& s)
727{
728 int len;
729 // check for zero added by sballar 2013-01-04
730 len = readInt();
731 if (len == 0)
732 s="";
733 else
734 {
735 // read the data
736 s = bData->substr(bDataPos, len);
737 bDataPos += len;
738 }
739}
740
744 inline void IFStreamBinary::readCharArray(string& s, int num_chars)
745{
746 s.resize(num_chars);
747 readCharArray(&s[0], num_chars);
748}
749
753 inline void IFStreamBinary::readCharArray(char* array, int num_chars)
754{
755 // read the data
756
757 memcpy(array, &(*bData)[bDataPos], num_chars);
758 bDataPos += num_chars;
759}
760
764 inline void IFStreamBinary::readType(string& s)
765{
766 readString(s);
767}
768
772 inline void IFStreamBinary::readTypeArray(string& s, int num_chars)
773{
774 readCharArray(s, num_chars);
775}
776
777//************* Read Bools ****************************************************
778
782 inline bool IFStreamBinary::readBool()
783{
784 // read the data
785
786 int pos = bDataPos;
787 bDataPos += CPPUtils::SBOL;
788 return readBool(pos);
789}
790
795 inline bool IFStreamBinary::readBool(int pos)
796{
797 return *((bool*) &(*bData)[pos]);
798}
799
803 inline void IFStreamBinary::readBoolArray(bool* array, int num_bools)
804{
805 // get bytes and perform alignment
806
807 int num_bytes = num_bools * CPPUtils::SBOL;
808
809 // copy from buffer into array ...
810 // update buffer position and exit
811
812 memcpy(array, &(*bData)[bDataPos], num_bytes);
813 bDataPos += num_bytes;
814}
815
819 inline void IFStreamBinary::readType(bool& b)
820{
821 b = readBool();
822}
823
827 inline void IFStreamBinary::readTypeArray(bool* array, int num_bools)
828{
829 readBoolArray(array, num_bools);
830}
831
832//************* Read Bytes ****************************************************
833
837 inline byte IFStreamBinary::readByte()
838{
839 // read the data
840
841 int pos = bDataPos;
842 bDataPos += CPPUtils::SBYT;
843 return readByte(pos);
844}
845
850 inline byte IFStreamBinary::readByte(int pos)
851{
852 return *((byte*) &(*bData)[pos]);
853}
854
858 inline void IFStreamBinary::readByteArray(byte* array, int num_bytes)
859{
860 // get bytes and perform alignment
861
862 num_bytes *= CPPUtils::SBYT;
863
864 // copy from buffer into array ...
865 // update buffer position and exit
866
867 memcpy(array, &(*bData)[bDataPos], num_bytes);
868 bDataPos += num_bytes;
869}
870
874 inline void IFStreamBinary::readType(byte& b)
875{
876 b = readByte();
877}
878
882 inline void IFStreamBinary::readTypeArray(byte* array, int num_bytes)
883{
884 readByteArray(array, num_bytes);
885}
886
887//************* Read Shorts ***************************************************
888
892 inline short IFStreamBinary::readShort()
893{
894 align2Byte();
895 return readShortNC();
896}
897
901 inline short IFStreamBinary::readShortNC()
902{
903 // read the data
904
905 int pos = bDataPos;
906 bDataPos += CPPUtils::SSHT;
907 return readShort(pos);
908}
909
914 inline short IFStreamBinary::readShort(int pos)
915{
916 // read the data ... use memcpy if alignment is off
917
918 short s;
919 if (bAlign)
920 s = *((short*) &(*bData)[pos]);
921 else
922 memcpy(&s, &(*bData)[pos], 2);
923
924 if (bReverse) reverseBO2((char*) &s);
925 return s;
926}
927
931 inline void IFStreamBinary::readShortArray(short* array, int num_shorts)
932{
933 // get bytes and perform alignment
934
935 int num_bytes = num_shorts * CPPUtils::SSHT;
936 align2Byte();
937
938 // copy from buffer into array ... reverse data if necessary ...
939 // update buffer position and exit
940
941 memcpy(array, &(*bData)[bDataPos], num_bytes);
942 if (bReverse) reverseBO2Array(num_shorts, (char*) array);
943 bDataPos += num_bytes;
944}
945
949 inline void IFStreamBinary::readType(short& s)
950{
951 s = readShort();
952}
953
957 inline void IFStreamBinary::readTypeArray(short* array, int num_shorts)
958{
959 readShortArray(array, num_shorts);
960}
961
962//************* Read Ints *****************************************************
963
967 inline int IFStreamBinary::readInt()
968{
969 align4Byte();
970 return readIntNC();
971}
972
976 inline int IFStreamBinary::readIntNC()
977{
978 // read the data
979
980 int pos = bDataPos;
981 bDataPos += CPPUtils::SINT;
982 return readInt(pos);
983}
984
989 inline int IFStreamBinary::readInt(int pos)
990{
991 // read the data ... use memcpy if alignment is off
992
993 int i;
994 if (bAlign)
995 i = *((int*) &(*bData)[pos]);
996 else
997 memcpy(&i, &(*bData)[pos], 4);
998
999 if (bReverse) reverseBO4((char*) &i);
1000 return i;
1001}
1002
1006 inline void IFStreamBinary::readIntArray(int* array, int num_ints)
1007{
1008 // get bytes and perform alignment
1009
1010 int num_bytes = num_ints * CPPUtils::SINT;
1011 align4Byte();
1012
1013 // copy from buffer into array ... reverse data if necessary ...
1014 // update buffer position and exit
1015
1016 memcpy(array, &(*bData)[bDataPos], num_bytes);
1017 if (bReverse) reverseBO4Array(num_ints, (char*) array);
1018 bDataPos += num_bytes;
1019}
1020
1024 inline void IFStreamBinary::readType(int& i)
1025{
1026 i = readInt();
1027}
1028
1032 inline void IFStreamBinary::readTypeArray(int* array, int num_ints)
1033{
1034 readIntArray(array, num_ints);
1035}
1036
1037//************* Read Longs ****************************************************
1038
1042 inline LONG_INT IFStreamBinary::readLong()
1043{
1044 align8Byte();
1045 return readLongNC();
1046}
1047
1051 inline LONG_INT IFStreamBinary::readLongNC()
1052{
1053 // read the data
1054
1055 int pos = bDataPos;
1056 bDataPos += CPPUtils::SLNG;
1057 return readLong(pos);
1058}
1059
1064 inline LONG_INT IFStreamBinary::readLong(int pos)
1065{
1066 // read the data ... use memcpy if alignment is off
1067
1068 LONG_INT l;
1069 if (bAlign)
1070 l = *((LONG_INT*) &(*bData)[pos]);
1071 else
1072 memcpy(&l, &(*bData)[pos], 8);
1073
1074 if (bReverse) reverseBO8((char*) &l);
1075 return l;
1076}
1077
1081 inline void IFStreamBinary::readLongArray(LONG_INT* array, int num_longs)
1082{
1083 // get bytes and perform alignment
1084
1085 int num_bytes = num_longs * CPPUtils::SLNG;
1086 align8Byte();
1087
1088 // copy from buffer into array ... reverse data if necessary ...
1089 // update buffer position and exit
1090
1091 memcpy(array, &(*bData)[bDataPos], num_bytes);
1092 if (bReverse) reverseBO8Array(num_longs, (char*) array);
1093 bDataPos += num_bytes;
1094}
1095
1099 inline void IFStreamBinary::readType(LONG_INT& l)
1100{
1101 l = readLong();
1102}
1103
1107 inline void IFStreamBinary::readTypeArray(LONG_INT* array, int num_longs)
1108{
1109 readLongArray(array, num_longs);
1110}
1111
1112//************* Read Floats ***************************************************
1113
1117 inline float IFStreamBinary::readFloat()
1118{
1119 align4Byte();
1120 return readFloatNC();
1121}
1122
1126 inline float IFStreamBinary::readFloatNC()
1127{
1128 // read the data
1129
1130 int pos = bDataPos;
1131 bDataPos += CPPUtils::SFLT;
1132 return readFloat(pos);
1133}
1134
1139 inline float IFStreamBinary::readFloat(int pos)
1140{
1141 // read the data ... use memcpy if alignment is off
1142
1143 float f;
1144 if (bAlign)
1145 f = *((float*) &(*bData)[pos]);
1146 else
1147 memcpy(&f, &(*bData)[pos], 4);
1148
1149 if (bReverse) reverseBO4((char*) &f);
1150 return f;
1151}
1152
1156 inline void IFStreamBinary::readFloatArray(float* array, int num_floats)
1157{
1158 // get bytes and perform alignment
1159
1160 int num_bytes = num_floats * CPPUtils::SFLT;
1161 align4Byte();
1162
1163 // copy from buffer into array ... reverse data if necessary ...
1164 // update buffer position and exit
1165
1166 memcpy(array, &(*bData)[bDataPos], num_bytes);
1167 if (bReverse) reverseBO4Array(num_floats, (char*) array);
1168 bDataPos += num_bytes;
1169}
1170
1174 inline void IFStreamBinary::readType(float& f)
1175{
1176 f = readFloat();
1177}
1178
1182 inline void IFStreamBinary::readTypeArray(float* array, int num_floats)
1183{
1184 readFloatArray(array, num_floats);
1185}
1186
1187//************* Read Doubles **************************************************
1188
1192 inline double IFStreamBinary::readDouble()
1193{
1194 align8Byte();
1195 return readDoubleNC();
1196}
1197
1201 inline double IFStreamBinary::readDoubleNC()
1202{
1203 // read the data
1204
1205 int pos = bDataPos;
1206 bDataPos += CPPUtils::SDBL;
1207 return readDouble(pos);
1208}
1209
1214 inline double IFStreamBinary::readDouble(int pos)
1215{
1216 // read the data ... use memcpy if alignment is off
1217
1218 double d;
1219 if (bAlign)
1220 d = *((double*) &(*bData)[pos]);
1221 else
1222 memcpy(&d, &(*bData)[pos], 8);
1223
1224 if (bReverse) reverseBO8((char*) &d);
1225 return d;
1226}
1227
1231 inline void IFStreamBinary::readDoubleArray(double* array, int num_doubles)
1232{
1233 // get bytes and perform alignment
1234
1235 int num_bytes = num_doubles * CPPUtils::SDBL;
1236 align8Byte();
1237
1238 // copy from buffer into array ... reverse data if necessary ...
1239 // update buffer position and exit
1240
1241 memcpy(array, &(*bData)[bDataPos], num_bytes);
1242 if (bReverse) reverseBO8Array(num_doubles, (char*) array);
1243 bDataPos += num_bytes;
1244}
1245
1249 inline void IFStreamBinary::readType(double& d)
1250{
1251 d = readDouble();
1252}
1253
1257 inline void IFStreamBinary::readTypeArray(double* array, int num_doubles)
1258{
1259 readDoubleArray(array, num_doubles);
1260}
1261
1262//************* Write Strings *************************************************
1263
1270 inline void IFStreamBinary::writeString(const string& str)
1271{
1272 // get total size, align, and check capacity
1273
1274 int sz = (int) str.size() + CPPUtils::SINT;
1275 align4Byte();
1276 checkBufferSize(sz);
1277
1278 // write the data
1279
1280 writeIntNC((int) str.size());
1281 memcpy(&(*bData)[bDataPos], &str[0], str.size());
1282 bDataPos += (int) str.size();
1283}
1284
1290 inline void IFStreamBinary::writeString(const char* char_string)
1291{
1292 string tmp_string = char_string;
1293 writeString(tmp_string);
1294}
1295
1299 inline void IFStreamBinary::writeCharArray(const char* array, int num_chars)
1300{
1301 checkBufferSize(num_chars);
1302
1303 // write data
1304
1305 memcpy(&(*bData)[bDataPos], array, num_chars);
1306 bDataPos += num_chars;
1307}
1308
1315 inline void IFStreamBinary::writeType(const string& str)
1316{
1317 writeString(str);
1318}
1319
1325 inline void IFStreamBinary::writeType(const char* char_string)
1326{
1327 writeString(char_string);
1328}
1329
1330//************* Write Bools ***************************************************
1331
1337 inline void IFStreamBinary::writeBool(bool b)
1338{
1339 checkBufferSize(CPPUtils::SBOL);
1340
1341 writeBoolNC(b);
1342}
1343
1349 inline void IFStreamBinary::writeBoolNC(bool b)
1350{
1351 writeBool(b, bDataPos);
1352 bDataPos += CPPUtils::SBOL;
1353}
1354
1360 inline void IFStreamBinary::writeBool(bool b, int pos)
1361{
1362 *((bool*) &(*bData)[pos]) = b;
1363}
1364
1368 inline void IFStreamBinary::writeBoolArray(const bool* array, int num_bools)
1369{
1370 // get number of bytes to be written and check for alignment and buffer
1371 // size
1372
1373 num_bools *= CPPUtils::SBOL;
1374 checkBufferSize(num_bools);
1375
1376 // copy array into data buffer. Reverse data buffer entries if necessary
1377 // and increment the buffer output pointer.
1378
1379 memcpy(&(*bData)[bDataPos], array, num_bools);
1380 bDataPos += num_bools;
1381}
1382
1388 inline void IFStreamBinary::writeType(bool b)
1389{
1390 writeBool(b);
1391}
1392
1396 inline void IFStreamBinary::writeTypeArray(const bool* array, int num_bools)
1397{
1398 writeBoolArray(array, num_bools);
1399}
1400
1401//************* Write Bytes ***************************************************
1402
1408 inline void IFStreamBinary::writeByte(byte b)
1409{
1410 checkBufferSize(CPPUtils::SBYT);
1411
1412 writeByteNC(b);
1413}
1414
1420 inline void IFStreamBinary::writeByteNC(byte b)
1421{
1422 writeByte(b, bDataPos);
1423 bDataPos += CPPUtils::SBYT;
1424}
1425
1431 inline void IFStreamBinary::writeByte(byte b, int pos)
1432{
1433 *((byte*) &(*bData)[pos]) = b;
1434}
1435
1439 inline void IFStreamBinary::writeByteArray(const byte* array, int num_bytes)
1440{
1441 // get number of bytes to be written and check for alignment and buffer
1442 // size
1443
1444 num_bytes *= CPPUtils::SBYT;
1445 checkBufferSize(num_bytes);
1446
1447 // copy array into data buffer. Reverse data buffer entries if necessary
1448 // and increment the buffer output pointer.
1449
1450 memcpy(&(*bData)[bDataPos], array, num_bytes);
1451 bDataPos += num_bytes;
1452}
1453
1459 inline void IFStreamBinary::writeType(byte b)
1460{
1461 writeByte(b);
1462}
1463
1467 inline void IFStreamBinary::writeTypeArray(const byte* array, int num_bytes)
1468{
1469 writeByteArray(array, num_bytes);
1470}
1471
1472//************* Write Shorts **************************************************
1473
1479 inline void IFStreamBinary::writeShort(short s)
1480{
1481 align2Byte();
1482 checkBufferSize(CPPUtils::SSHT);
1483
1484 writeShortNC(s);
1485}
1486
1492 inline void IFStreamBinary::writeShortNC(short s)
1493{
1494 writeShort(s, bDataPos);
1495 bDataPos += CPPUtils::SSHT;
1496}
1497
1503 inline void IFStreamBinary::writeShort(short s, int pos)
1504{
1505 if (bReverse) reverseBO2((char*) &s);
1506
1507 if (bAlign)
1508 *((short*) &(*bData)[pos]) = s;
1509 else
1510 memcpy(&(*bData)[pos], &s, CPPUtils::SSHT);
1511}
1512
1516 inline void IFStreamBinary::writeShortArray(const short* array, int num_shorts)
1517{
1518 // get number of bytes to be written and check for alignment and buffer
1519 // size
1520
1521 int num_bytes = num_shorts * CPPUtils::SSHT;
1522 align2Byte();
1523 checkBufferSize(num_bytes);
1524
1525 // copy array into data buffer. Reverse data buffer entries if necessary
1526 // and increment the buffer output pointer.
1527
1528 memcpy(&(*bData)[bDataPos], array, num_bytes);
1529 if (bReverse) reverseBO2Array(num_shorts, &(*bData)[bDataPos]);
1530 bDataPos += num_bytes;
1531}
1532
1538 inline void IFStreamBinary::writeType(short s)
1539{
1540 writeShort(s);
1541}
1542
1546 inline void IFStreamBinary::writeTypeArray(const short* array, int num_shorts)
1547{
1548 writeShortArray(array, num_shorts);
1549}
1550
1551//************* Write Ints ****************************************************
1552
1558 inline void IFStreamBinary::writeInt(int i)
1559{
1560 align4Byte();
1561 checkBufferSize(CPPUtils::SINT);
1562
1563 writeIntNC(i);
1564}
1565
1571 inline void IFStreamBinary::writeIntNC(int i)
1572{
1573 writeInt(i, bDataPos);
1574 bDataPos += CPPUtils::SINT;
1575}
1576
1582 inline void IFStreamBinary::writeInt(int i, int pos)
1583{
1584 if (bReverse) reverseBO4((char*) &i);
1585
1586 if (bAlign)
1587 *((int*) &(*bData)[pos]) = i;
1588 else
1589 memcpy(&(*bData)[pos], &i, CPPUtils::SINT);
1590}
1591
1595 inline void IFStreamBinary::writeIntArray(const int* array, int num_ints)
1596{
1597 // get number of bytes to be written and check for alignment and buffer
1598 // size
1599
1600 int num_bytes = num_ints * CPPUtils::SINT;
1601 align4Byte();
1602 checkBufferSize(num_bytes);
1603
1604 // copy array into data buffer. Reverse data buffer entries if necessary
1605 // and increment the buffer output pointer.
1606
1607 memcpy(&(*bData)[bDataPos], array, num_bytes);
1608 if (bReverse) reverseBO4Array(num_ints, &(*bData)[bDataPos]);
1609 bDataPos += num_bytes;
1610}
1611
1617 inline void IFStreamBinary::writeType(int i)
1618{
1619 writeInt(i);
1620}
1621
1625 inline void IFStreamBinary::writeTypeArray(const int* array, int num_ints)
1626{
1627 writeIntArray(array, num_ints);
1628}
1629
1630//************* Write Longs ***************************************************
1631
1637 inline void IFStreamBinary::writeLong(LONG_INT l)
1638{
1639 align8Byte();
1640 checkBufferSize(CPPUtils::SLNG);
1641
1642 writeLongNC(l);
1643}
1644
1650 inline void IFStreamBinary::writeLongNC(LONG_INT l)
1651{
1652 writeLong(l, bDataPos);
1653 bDataPos += CPPUtils::SLNG;
1654}
1655
1661 inline void IFStreamBinary::writeLong(LONG_INT l, int pos)
1662{
1663 if (bReverse) reverseBO8((char*) &l);
1664
1665 if (bAlign)
1666 *((LONG_INT*) &(*bData)[pos]) = l;
1667 else
1668 memcpy(&(*bData)[pos], &l, CPPUtils::SLNG);
1669}
1670
1674 inline void IFStreamBinary::writeLongArray(const LONG_INT* array, int num_longs)
1675{
1676 // get number of bytes to be written and check for alignment and buffer
1677 // size
1678
1679 int num_bytes = num_longs * CPPUtils::SLNG;
1680 align8Byte();
1681 checkBufferSize(num_bytes);
1682
1683 // copy array into data buffer. Reverse data buffer entries if necessary
1684 // and increment the buffer output pointer.
1685
1686 memcpy(&(*bData)[bDataPos], array, num_bytes);
1687 if (bReverse) reverseBO8Array(num_longs, &(*bData)[bDataPos]);
1688 bDataPos += num_bytes;
1689}
1690
1696 inline void IFStreamBinary::writeType(LONG_INT l)
1697{
1698 writeLong(l);
1699}
1700
1704 inline void IFStreamBinary::writeTypeArray(const LONG_INT* array, int num_longs)
1705{
1706 writeLongArray(array, num_longs);
1707}
1708
1709//************* Write Floats **************************************************
1710
1716 inline void IFStreamBinary::writeFloat(float f)
1717{
1718 align4Byte();
1719 checkBufferSize(CPPUtils::SFLT);
1720
1721 writeFloatNC(f);
1722}
1723
1729 inline void IFStreamBinary::writeFloatNC(float f)
1730{
1731 writeFloat(f, bDataPos);
1732 bDataPos += CPPUtils::SFLT;
1733}
1734
1740 inline void IFStreamBinary::writeFloat(float f, int pos)
1741{
1742 if (bReverse) reverseBO4((char*) &f);
1743
1744 if (bAlign)
1745 *((float*) &(*bData)[pos]) = f;
1746 else
1747 memcpy(&(*bData)[pos], &f, CPPUtils::SFLT);
1748}
1749
1753 inline void IFStreamBinary::writeFloatArray(const float* array, int num_floats)
1754{
1755 // get number of bytes to be written and check for alignment and buffer
1756 // size
1757
1758 int num_bytes = num_floats * CPPUtils::SFLT;
1759 align4Byte();
1760 checkBufferSize(num_bytes);
1761
1762 // copy array into data buffer. Reverse data buffer entries if necessary
1763 // and increment the buffer output pointer.
1764
1765 memcpy(&(*bData)[bDataPos], array, num_bytes);
1766 if (bReverse) reverseBO4Array(num_floats, &(*bData)[bDataPos]);
1767 bDataPos += num_bytes;
1768}
1769
1775 inline void IFStreamBinary::writeType(float f)
1776{
1777 writeFloat(f);
1778}
1779
1783 inline void IFStreamBinary::writeTypeArray(const float* array, int num_floats)
1784{
1785 writeFloatArray(array, num_floats);
1786}
1787
1788//************* Write Doubles *************************************************
1789
1795 inline void IFStreamBinary::writeDouble(double d)
1796{
1797 align8Byte();
1798 checkBufferSize(CPPUtils::SDBL);
1799
1800 writeDoubleNC(d);
1801}
1802
1808 inline void IFStreamBinary::writeDoubleNC(double d)
1809{
1810 writeDouble(d, bDataPos);
1811 bDataPos += CPPUtils::SDBL;
1812}
1813
1819 inline void IFStreamBinary::writeDouble(double d, int pos)
1820{
1821 if (bReverse) reverseBO8((char*) &d);
1822
1823 if (bAlign)
1824 *((double*) &(*bData)[pos]) = d;
1825 else
1826 memcpy(&(*bData)[pos], &d, CPPUtils::SDBL);
1827}
1828
1832 inline void IFStreamBinary::writeDoubleArray(const double* array, int num_doubles)
1833{
1834 // get number of bytes to be written and check for alignment and buffer
1835 // size
1836
1837 int num_bytes = num_doubles * CPPUtils::SDBL;
1838 align8Byte();
1839 checkBufferSize(num_bytes);
1840
1841 // copy array into data buffer. Reverse data buffer entries if necessary
1842 // and increment the buffer output pointer.
1843
1844 memcpy(&(*bData)[bDataPos], array, num_bytes);
1845 if (bReverse) reverseBO8Array(num_doubles, &(*bData)[bDataPos]);
1846 bDataPos += num_bytes;
1847}
1848
1854 inline void IFStreamBinary::writeType(double d)
1855{
1856 writeDouble(d);
1857}
1858
1862 inline void IFStreamBinary::writeTypeArray(const double* array, int num_doubles)
1863{
1864 writeDoubleArray(array, num_doubles);
1865}
1866
1867//************* Byte reversal functions ***************************************
1868
1872 inline void IFStreamBinary::reverseBO2(char* d)
1873{
1874 char tmp = d[0];
1875 d[0] = d[1];
1876 d[1] = tmp;
1877}
1878
1882 inline void IFStreamBinary::reverseBO4(char* d)
1883{
1884 char tmp = d[0];
1885 d[0] = d[3];
1886 d[3] = tmp;
1887
1888 tmp = d[1];
1889 d[1] = d[2];
1890 d[2] = tmp;
1891}
1892
1896 inline void IFStreamBinary::reverseBO8(char* d)
1897{
1898 char tmp = d[0];
1899 d[0] = d[7];
1900 d[7] = tmp;
1901
1902 tmp = d[1];
1903 d[1] = d[6];
1904 d[6] = tmp;
1905
1906 tmp = d[2];
1907 d[2] = d[5];
1908 d[5] = tmp;
1909
1910 tmp = d[3];
1911 d[3] = d[4];
1912 d[4] = tmp;
1913}
1914
1915} // end namespace geotess
1916
1917#endif // IFSTREAMBINARY_OBJECT_H
GEOTESS_EXP_IMP
#define GEOTESS_EXP_IMP
Definition CPPGlobals.h:71
LONG_INT
#define LONG_INT
Definition CPPGlobals.h:111
CPPUtils.h
GeoTessException.h
GeoTessUtils.h
geotess::CPPUtils::SBYT
static const int SBYT
Definition CPPUtils.h:353
geotess::CPPUtils::SINT
static const int SINT
Definition CPPUtils.h:355
geotess::CPPUtils::SSHT
static const int SSHT
Definition CPPUtils.h:354
geotess::CPPUtils::SLNG
static const int SLNG
Definition CPPUtils.h:356
geotess::CPPUtils::SFLT
static const int SFLT
Definition CPPUtils.h:357
geotess::CPPUtils::SDBL
static const int SDBL
Definition CPPUtils.h:358
geotess::CPPUtils::SBOL
static const int SBOL
Definition CPPUtils.h:352
geotess::IFStreamBinary::writeIntNC
void writeIntNC(int i)
Definition IFStreamBinary.h:1571
geotess::IFStreamBinary::resetPos
void resetPos()
Definition IFStreamBinary.h:598
geotess::IFStreamBinary::IFStreamBinary
IFStreamBinary(bool align)
geotess::IFStreamBinary::readInt
int readInt()
Definition IFStreamBinary.h:967
geotess::IFStreamBinary::writeToFile
void writeToFile(ofstream &ofs)
geotess::IFStreamBinary::reserve
void reserve(int sze)
Definition IFStreamBinary.h:583
geotess::IFStreamBinary::writeString
void writeString(const string &str)
Definition IFStreamBinary.h:1270
geotess::IFStreamBinary::bDataPos
int bDataPos
Definition IFStreamBinary.h:91
geotess::IFStreamBinary::writeDoubleNC
void writeDoubleNC(double d)
Definition IFStreamBinary.h:1808
geotess::IFStreamBinary::writeFloatArray
void writeFloatArray(const float *array, int num_floats)
Definition IFStreamBinary.h:1753
geotess::IFStreamBinary::readLongNC
LONG_INT readLongNC()
Definition IFStreamBinary.h:1051
geotess::IFStreamBinary::~IFStreamBinary
virtual ~IFStreamBinary()
geotess::IFStreamBinary::byteOrderReverseOn
void byteOrderReverseOn()
Definition IFStreamBinary.h:668
geotess::IFStreamBinary::setBoundaryAlignment
void setBoundaryAlignment(bool align)
Definition IFStreamBinary.h:687
geotess::IFStreamBinary::readBool
bool readBool()
Definition IFStreamBinary.h:782
geotess::IFStreamBinary::className
static string className()
Definition IFStreamBinary.h:564
geotess::IFStreamBinary::bSize
int bSize
Definition IFStreamBinary.h:96
geotess::IFStreamBinary::writeShortArray
void writeShortArray(const short *array, int num_ints)
Definition IFStreamBinary.h:1516
geotess::IFStreamBinary::reverseBO8Array
static void reverseBO8Array(int n, char *a)
geotess::IFStreamBinary::readString
string readString()
Definition IFStreamBinary.h:716
geotess::IFStreamBinary::isBoundaryAlignmentOn
bool isBoundaryAlignmentOn() const
Definition IFStreamBinary.h:706
geotess::IFStreamBinary::writeBoolNC
void writeBoolNC(bool b)
Definition IFStreamBinary.h:1349
geotess::IFStreamBinary::bOwnStr
bool bOwnStr
Definition IFStreamBinary.h:118
geotess::IFStreamBinary::incrementPos
void incrementPos(int increment=1)
Definition IFStreamBinary.h:622
geotess::IFStreamBinary::writeIntArray
void writeIntArray(const int *array, int num_ints)
Definition IFStreamBinary.h:1595
geotess::IFStreamBinary::boundaryAlignmentOff
void boundaryAlignmentOff()
Definition IFStreamBinary.h:699
geotess::IFStreamBinary::readByte
byte readByte()
Definition IFStreamBinary.h:837
geotess::IFStreamBinary::align8Byte
void align8Byte()
Definition IFStreamBinary.h:148
geotess::IFStreamBinary::reverseBOArray
static void reverseBOArray(int n, char *a, int s)
geotess::IFStreamBinary::IFStreamBinary
IFStreamBinary(const IFStreamBinary &db)
geotess::IFStreamBinary::writeBool
void writeBool(bool b)
Definition IFStreamBinary.h:1337
geotess::IFStreamBinary::writeByte
void writeByte(byte b)
Definition IFStreamBinary.h:1408
geotess::IFStreamBinary::readCharArray
void readCharArray(string &s, int num_chars)
Definition IFStreamBinary.h:744
geotess::IFStreamBinary::writeDoubleArray
void writeDoubleArray(const double *array, int num_doubles)
Definition IFStreamBinary.h:1832
geotess::IFStreamBinary::exists
static bool exists(const string &filename)
geotess::IFStreamBinary::bReverse
bool bReverse
Definition IFStreamBinary.h:111
geotess::IFStreamBinary::readIntNC
int readIntNC()
Definition IFStreamBinary.h:976
geotess::IFStreamBinary::readLong
LONG_INT readLong()
Definition IFStreamBinary.h:1042
geotess::IFStreamBinary::setMemoryCapacityIncrement
void setMemoryCapacityIncrement(int mci)
Definition IFStreamBinary.h:297
geotess::IFStreamBinary::readFromFile
void readFromFile(const string &filename, int num_bytes)
geotess::IFStreamBinary::writeToFile
void writeToFile(const string &filename)
geotess::IFStreamBinary::IFStreamBinary
IFStreamBinary(string *str)
geotess::IFStreamBinary::readShortNC
short readShortNC()
Definition IFStreamBinary.h:901
geotess::IFStreamBinary::bMemIncr
int bMemIncr
Definition IFStreamBinary.h:122
geotess::IFStreamBinary::writeBoolArray
void writeBoolArray(const bool *array, int num_bools)
Definition IFStreamBinary.h:1368
geotess::IFStreamBinary::checkBufferSize
void checkBufferSize(int sincr)
Definition IFStreamBinary.h:158
geotess::IFStreamBinary::writeLongNC
void writeLongNC(LONG_INT l)
Definition IFStreamBinary.h:1650
geotess::IFStreamBinary::writeDouble
void writeDouble(double d)
Definition IFStreamBinary.h:1795
geotess::IFStreamBinary::readFloat
float readFloat()
Definition IFStreamBinary.h:1117
geotess::IFStreamBinary::setPosToEnd
void setPosToEnd()
Definition IFStreamBinary.h:607
geotess::IFStreamBinary::boundaryAlignmentOn
void boundaryAlignmentOn()
Definition IFStreamBinary.h:693
geotess::IFStreamBinary::dumpBuffer
void dumpBuffer()
geotess::IFStreamBinary::readIntArray
void readIntArray(int *array, int num_ints)
Definition IFStreamBinary.h:1006
geotess::IFStreamBinary::readType
void readType(string &s)
Definition IFStreamBinary.h:764
geotess::IFStreamBinary::bAlign
bool bAlign
Definition IFStreamBinary.h:102
geotess::IFStreamBinary::writeShortNC
void writeShortNC(short i)
Definition IFStreamBinary.h:1492
geotess::IFStreamBinary::reSize
void reSize(int spc)
Definition IFStreamBinary.h:577
geotess::IFStreamBinary::setByteOrderReverse
void setByteOrderReverse(bool bor)
Definition IFStreamBinary.h:662
geotess::IFStreamBinary::bFileName
string bFileName
Definition IFStreamBinary.h:120
geotess::IFStreamBinary::readTypeArray
void readTypeArray(string &array, int num_chars)
Definition IFStreamBinary.h:772
geotess::IFStreamBinary::writeShort
void writeShort(short i)
Definition IFStreamBinary.h:1479
geotess::IFStreamBinary::readDoubleNC
double readDoubleNC()
Definition IFStreamBinary.h:1201
geotess::IFStreamBinary::reverseBO4
static void reverseBO4(char *d)
Definition IFStreamBinary.h:1882
geotess::IFStreamBinary::byteOrderReverseOff
void byteOrderReverseOff()
Definition IFStreamBinary.h:674
geotess::IFStreamBinary::readDouble
double readDouble()
Definition IFStreamBinary.h:1192
geotess::IFStreamBinary::classSize
static int classSize()
Definition IFStreamBinary.h:570
geotess::IFStreamBinary::readByteArray
void readByteArray(byte *array, int num_bs)
Definition IFStreamBinary.h:858
geotess::IFStreamBinary::getPosPointer
char * getPosPointer(int pos)
Definition IFStreamBinary.h:653
geotess::IFStreamBinary::getData
const string & getData() const
Definition IFStreamBinary.h:634
geotess::IFStreamBinary::writeLongArray
void writeLongArray(const LONG_INT *array, int num_longs)
Definition IFStreamBinary.h:1674
geotess::IFStreamBinary::getPos
int getPos() const
Definition IFStreamBinary.h:616
geotess::IFStreamBinary::writeFloat
void writeFloat(float f)
Definition IFStreamBinary.h:1716
geotess::IFStreamBinary::readFromFile
void readFromFile(const string &filename)
geotess::IFStreamBinary::isByteOrderReversalOn
bool isByteOrderReversalOn() const
Definition IFStreamBinary.h:681
geotess::IFStreamBinary::writeCharArray
void writeCharArray(const char *array, int num_chars)
Definition IFStreamBinary.h:1299
geotess::IFStreamBinary::readFloatNC
float readFloatNC()
Definition IFStreamBinary.h:1126
geotess::IFStreamBinary::writeInt
void writeInt(int i)
Definition IFStreamBinary.h:1558
geotess::IFStreamBinary::readShortArray
void readShortArray(short *array, int num_shorts)
Definition IFStreamBinary.h:931
geotess::IFStreamBinary::IFStreamBinary
IFStreamBinary()
geotess::IFStreamBinary::align2Byte
void align2Byte()
Definition IFStreamBinary.h:128
geotess::IFStreamBinary::readDoubleArray
void readDoubleArray(double *array, int num_doubles)
Definition IFStreamBinary.h:1231
geotess::IFStreamBinary::readFloatArray
void readFloatArray(float *array, int num_floats)
Definition IFStreamBinary.h:1156
geotess::IFStreamBinary::writeByteArray
void writeByteArray(const byte *array, int num_bytes)
Definition IFStreamBinary.h:1439
geotess::IFStreamBinary::reverseBO2
static void reverseBO2(char *d)
Definition IFStreamBinary.h:1872
geotess::IFStreamBinary::readFromFile
void readFromFile(ifstream &ifs, int num_bytes)
geotess::IFStreamBinary::bData
string * bData
Definition IFStreamBinary.h:86
geotess::IFStreamBinary::operator=
IFStreamBinary & operator=(const IFStreamBinary &db)
geotess::IFStreamBinary::writeLong
void writeLong(LONG_INT l)
Definition IFStreamBinary.h:1637
geotess::IFStreamBinary::IFStreamBinary
IFStreamBinary(const string &filename, int num_bytes)
geotess::IFStreamBinary::readBoolArray
void readBoolArray(bool *array, int num_bools)
Definition IFStreamBinary.h:803
geotess::IFStreamBinary::writeTypeArray
void writeTypeArray(const bool *array, int num_bools)
Definition IFStreamBinary.h:1396
geotess::IFStreamBinary::decrementPos
void decrementPos(int decrement=1)
Definition IFStreamBinary.h:628
geotess::IFStreamBinary::reverseBO8
static void reverseBO8(char *d)
Definition IFStreamBinary.h:1896
geotess::IFStreamBinary::readShort
short readShort()
Definition IFStreamBinary.h:892
geotess::IFStreamBinary::reverseBO4Array
static void reverseBO4Array(int n, char *a)
geotess::IFStreamBinary::size
int size()
Definition IFStreamBinary.h:589
geotess::IFStreamBinary::IFStreamBinary
IFStreamBinary(const string &filename)
geotess::IFStreamBinary::clear
void clear()
Definition IFStreamBinary.h:286
geotess::IFStreamBinary::writeByteNC
void writeByteNC(byte b)
Definition IFStreamBinary.h:1420
geotess::IFStreamBinary::getPosPointer
char * getPosPointer()
Definition IFStreamBinary.h:647
geotess::IFStreamBinary::getFileName
const string & getFileName() const
Definition IFStreamBinary.h:281
geotess::IFStreamBinary::align4Byte
void align4Byte()
Definition IFStreamBinary.h:138
geotess::IFStreamBinary::reverseBO2Array
static void reverseBO2Array(int n, char *a)
geotess::IFStreamBinary::getCapacity
int getCapacity() const
Definition IFStreamBinary.h:640
geotess::IFStreamBinary::writeFloatNC
void writeFloatNC(float f)
Definition IFStreamBinary.h:1729
geotess::IFStreamBinary::writeType
void writeType(const string &str)
Definition IFStreamBinary.h:1315
geotess::IFStreamBinary::readLongArray
void readLongArray(LONG_INT *array, int num_longs)
Definition IFStreamBinary.h:1081
geotess
Definition ArrayReuse.h:55