source: pacpusframework/branches/2.0-beta1/src/FileLib/src/DbiteFile.cpp@ 89

Last change on this file since 89 was 89, checked in by morasjul, 11 years ago

PACPUS 2.0 Beta deployed in new branch

Major changes:
-Add communication interface between components
-Add examples for communications interface (TestComponents)
-Move to Qt5 support

  • Property svn:executable set to *
File size: 22.3 KB
Line 
1// %pacpus:license{
2// This file is part of the PACPUS framework distributed under the
3// CECILL-C License, Version 1.0.
4// %pacpus:license}
5/// @version $Id: DbiteFile.cpp 76 2013-01-10 17:05:10Z kurdejma $
6
7#include <Pacpus/kernel/DbiteFile.h>
8#include <Pacpus/kernel/DbiteException.h>
9#include <Pacpus/kernel/DbiteFileTypes.h>
10#include <Pacpus/kernel/Log.h>
11
12#include <cassert>
13#include <cmath>
14#include <iostream>
15#include <limits>
16#include <sstream>
17
18using namespace pacpus;
19using namespace std;
20
21// FIXME: record size is only 8-bit long!
22typedef int8_t VariableDataSizeT;
23
24DECLARE_STATIC_LOGGER("pacpus.core.DbiteFile");
25
26namespace pacpus
27{
28 VariableDataSizeTag VariableDataSize;
29 ReadModeTag ReadMode;
30 WriteModeTag WriteMode;
31 DiagnoseModeTag DiagnoseMode;
32}
33
34bool doesFileExist(const string & path);
35
36DbiteFile::DbiteFile()
37 : mIsWriting(false)
38{
39 setPath("");
40
41 (void) ReadMode; // unused
42 (void) WriteMode; // unused
43 (void) VariableDataSize; // unused
44 (void) DiagnoseMode; // unused
45}
46
47DbiteFile::~DbiteFile()
48{
49 if (isOpen()) {
50 close();
51 }
52}
53
54DbiteFile::operator string()
55{
56 static const int64_t kMicrosInSecond = 1000 * 1000;
57 stringstream os;
58
59 os << "Signature : " << getSignature() << endl;
60 os << "Version : " << getVersion() << endl;
61 os << "Header size : " << getDataOffset() << " [bytes]" << endl;
62 os << "Record size : " << getRecordSize() << " [bytes]" << endl;
63 os << "Data type : " << getType() << endl;
64 os << "Time min. : " << getTimeMin() << endl;
65 os << "Time max. : " << getTimeMax() << endl;
66 os << "Duration : " << (getTimeMax() - getTimeMin()) / kMicrosInSecond << " [seconds]" << endl;
67 os << "File size : " << getFileSize() << " [bytes]" << endl;
68 os << "Record count : " << getRecordCount() << endl;
69
70 return os.str();
71}
72
73const string & DbiteFile::getPath() const
74{
75 return mPath;
76}
77
78void DbiteFile::setPath(const string & path)
79{
80 mPath = path;
81}
82
83void DbiteFile::open(const string & path, ReadModeTag)
84{
85 mIsWriting = false;
86 if (isOpen()) {
87 LOG_DEBUG("file is already open, closing...");
88 close();
89 }
90
91 setPath(path);
92
93 mFile.open(getPath().c_str(), ios_base::binary | ios_base::in);
94 try {
95 checkFileOpen();
96 } catch (DbiteException & e) {
97 LOG_ERROR("Dbite exception: " << e.what());
98 close();
99 throw DbiteException("cannot open file for reading");
100 }
101
102 try {
103 readHeader();
104 } catch (DbiteException & e) {
105 LOG_ERROR("Dbite exception: " << e.what());
106 // TODO: readAndDiagnoseHeader();
107 close();
108 throw DbiteException("cannot read header");
109 }
110 verifyHeader();
111 goToDataBegin();
112}
113
114void DbiteFile::open(const string & path, WriteModeTag)
115{
116 openWriteMode(path);
117}
118
119void DbiteFile::open(const string & path, WriteModeTag, hdfile_header_t::DataTypeT type, hdfile_header_t::DataSizeT dataSize)
120{
121 openWriteMode(path, type);
122 setRecordSize(dataSize);
123}
124
125void DbiteFile::open(const string & path, WriteModeTag, hdfile_header_t::DataTypeT type, VariableDataSizeTag tag)
126{
127 openWriteMode(path, type);
128 setRecordSize(tag);
129}
130
131void DbiteFile::openWriteMode(const string & path, hdfile_header_t::DataTypeT type)
132{
133 openWriteMode(path);
134 setType(type);
135}
136
137void DbiteFile::openWriteMode(const string & path)
138{
139 mIsWriting = true;
140 if (isOpen()) {
141 LOG_DEBUG("file is already open, closing...");
142 close();
143 }
144
145 setPath(path);
146 bool fileExists = doesFileExist(path);
147 ios_base::openmode openmode;
148 if (fileExists) {
149 openmode = ios_base::binary | ios_base::in | ios_base::out;
150 } else {
151 openmode = ios_base::binary | ios_base::out;
152 }
153 mFile.open(getPath().c_str(), openmode);
154 if (!isOpen()) {
155 LOG_ERROR("cannot open file for writing");
156 throw DbiteException("cannot open file for writing");
157 }
158
159 if (fileExists) {
160 // file exists
161 LOG_DEBUG("file already exists, appending");
162 try {
163 readHeader();
164 // TODO: check if same type and record size
165 } catch (DbiteException & e) {
166 LOG_ERROR("Dbite exception: " << e.what());
167 // TODO: readAndDiagnoseHeader();
168 close();
169 throw DbiteException("cannot read header");
170 }
171 } else {
172 // file does not exist
173 initializeHeader();
174 writeHeader();
175 }
176 //goToDataBegin();
177 goToFileEnd();
178}
179
180void DbiteFile::initializeHeader()
181{
182 setSignature();
183 setType(FILE_DBT_UNKNOWN);
184 setVersion(VERSION_NUMBER);
185 setDataOffset(sizeof(hdfile_header_t));
186 setRecordSize(0);
187 // same as header size
188 setFileSize(getDataOffset());
189 setTimeMin(numeric_limits<road_time_t>::max());
190 setTimeMax(numeric_limits<road_time_t>::min());
191 setRecordCount(0);
192}
193
194void DbiteFile::close()
195{
196 if (!isOpen()) {
197 LOG_WARN("file is not open");
198 return;
199 }
200 closeDbite();
201 setPath("");
202}
203
204void DbiteFile::closeDbite()
205{
206 if (mIsWriting) {
207 try {
208 writeHeader();
209 } catch (DbiteException & e) {
210 LOG_ERROR("cannot write header on close: " << e.what());
211 }
212 }
213 mFile.close();
214}
215
216bool DbiteFile::isOpen() const
217{
218 return mFile.is_open();
219}
220
221void DbiteFile::goToFileBegin()
222{
223 LOG_DEBUG("goToFileBegin()");
224 mFile.clear();
225 setReadPosition(0);
226 setWritePosition(0);
227}
228
229void DbiteFile::goToDataBegin()
230{
231 LOG_DEBUG("goToDataBegin()");
232 LOG_TRACE("getDataOffset() = " << getDataOffset());
233 mFile.clear();
234 setReadPosition(getDataOffset());
235 setWritePosition(getDataOffset());
236}
237
238void DbiteFile::goToFileEnd()
239{
240 LOG_TRACE("goToFileEnd()");
241 LOG_TRACE("getFileSize() = " << getFileSize());
242 mFile.clear();
243 // do not use fstream::seekg/seekp(0, ios_base::end),
244 // because in case of write failure,
245 // we should write at position=getFileSize() which can be before the actual file end
246 setReadPosition(getFileSize());
247 setWritePosition(getFileSize());
248}
249
250int64_t DbiteFile::getReadPosition()
251{
252 checkFileOpen();
253 return mFile.tellg();
254}
255
256int64_t DbiteFile::getWritePosition()
257{
258 checkFileOpen();
259 return mFile.tellp();
260}
261
262void DbiteFile::setReadPosition(int64_t offset, ios_base::seekdir direction)
263{
264 LOG_TRACE("set read position = " << offset << " direction = " << direction);
265 checkFileOpen();
266 mFile.seekg(offset, direction);
267 if (mFile.fail()) {
268 LOG_ERROR("failed to set write position");
269 }
270}
271
272void DbiteFile::setReadPosition(int64_t position)
273{
274 LOG_TRACE("set read position = " << position);
275 checkFileOpen();
276 mFile.seekg(position);
277 if (mFile.fail()) {
278 LOG_ERROR("failed to set read position");
279 }
280}
281
282void DbiteFile::setWritePosition(int64_t offset, ios_base::seekdir direction)
283{
284 LOG_TRACE("set write position = " << offset << " direction = " << direction);
285 checkFileOpen();
286 mFile.seekp(offset, direction);
287 if (mFile.fail()) {
288 LOG_ERROR("failed to set write position");
289 }
290}
291
292void DbiteFile::setWritePosition(int64_t position)
293{
294 LOG_TRACE("set write position = " << position);
295 checkFileOpen();
296 mFile.seekp(position);
297 if (mFile.fail()) {
298 LOG_ERROR("failed to set write position");
299 }
300}
301
302const hdfile_header_t & DbiteFile::getHeader() const
303{
304 return mHeader;
305}
306
307hdfile_header_t & DbiteFile::header()
308{
309 return mHeader;
310}
311
312void DbiteFile::readHeader()
313{
314 goToFileBegin();
315 checkFileOpen();
316 read((char *)(&mHeader), sizeof(mHeader));
317 LOG_DEBUG("file: " << getPath());
318 LOG_TRACE("header read:\n" << string(*this));
319}
320
321void DbiteFile::verifyHeader()
322{
323 // verify file size
324 const int64_t realFileSize = getRealFileSize();
325 const hdfile_header_t::FileSizeT fileSize = getFileSize();
326 if (realFileSize != fileSize) {
327 LOG_WARN("real file size different than header information");
328 LOG_INFO("real file size = " << realFileSize);
329 LOG_INFO("file size = " << fileSize);
330 }
331
332 if (getVersion() != VERSION_NUMBER) {
333 LOG_ERROR("bad version number");
334 throw DbiteException("bad version number");
335 }
336
337 if (!isSignatureCorrect()) {
338 LOG_ERROR("bad signature");
339 throw DbiteException("bad signature");
340 }
341
342 LOG_DEBUG("header verified");
343}
344
345void DbiteFile::writeHeader()
346{
347 LOG_DEBUG("writing header:\n" << string(*this));
348
349 goToFileBegin();
350
351 LOG_DEBUG("begin position=" << getWritePosition());
352
353 const size_t bytesToWrite = sizeof(mHeader);
354 write((char *)(&mHeader), bytesToWrite);
355 LOG_DEBUG("header written");
356
357 LOG_DEBUG("final position=" << getWritePosition());
358}
359
360string DbiteFile::getSignature() const
361{
362 const char signature[] = { getHeader().Signature[0], getHeader().Signature[1], getHeader().Signature[2], getHeader().Signature[3], '\0' };
363 return signature;
364}
365
366bool DbiteFile::isSignatureCorrect() const
367{
368 if ('R' != getHeader().Signature[0]) {
369 return false;
370 }
371 if ('O' != getHeader().Signature[1]) {
372 return false;
373 }
374 if ('A' != getHeader().Signature[2]) {
375 return false;
376 }
377 if ('D' != getHeader().Signature[3]) {
378 return false;
379 }
380 return true;
381}
382
383void DbiteFile::setSignature()
384{
385 header().Signature[0] = 'R';
386 header().Signature[1] = 'O';
387 header().Signature[2] = 'A';
388 header().Signature[3] = 'D';
389}
390
391hdfile_header_t::DataTypeT DbiteFile::getType() const
392{
393 return getHeader().Type;
394}
395
396void DbiteFile::setType(hdfile_header_t::DataTypeT type)
397{
398 header().Type = type;
399}
400
401hdfile_header_t::VersionT DbiteFile::getVersion() const
402{
403 return getHeader().VersionNumber;
404}
405
406void DbiteFile::setVersion(hdfile_header_t::VersionT version)
407{
408 header().VersionNumber = version;
409}
410
411hdfile_header_t::DataOffsetT DbiteFile::getDataOffset() const
412{
413 return getHeader().DataOffset;
414}
415
416void DbiteFile::setDataOffset(hdfile_header_t::DataOffsetT dataOffset)
417{
418 header().DataOffset = dataOffset;
419}
420
421hdfile_header_t::DataSizeT DbiteFile::getRecordSize() const
422{
423 return getHeader().DataSize;
424}
425
426void DbiteFile::setRecordSize(hdfile_header_t::DataSizeT recordSize)
427{
428 header().DataSize = recordSize;
429}
430
431void DbiteFile::setRecordSize(VariableDataSizeTag)
432{
433 header().DataSize = hdfile_header_t::kVariableRecordSize;
434}
435
436hdfile_header_t::FileSizeT DbiteFile::getFileSize() const
437{
438 if (getHeader().FileSize < getHeader().DataOffset) {
439 LOG_WARN("wrong header information: file size lesser than data offset");
440 }
441 return getHeader().FileSize;
442}
443
444void DbiteFile::setFileSize(hdfile_header_t::FileSizeT fileSize)
445{
446 header().FileSize = fileSize;
447}
448
449int64_t DbiteFile::getRealFileSize()
450{
451 checkFileOpen();
452
453 mFile.clear();
454 // save position
455 int64_t oldReadPosition = getReadPosition();
456 int64_t oldWritePosition = getWritePosition();
457
458 // go to file end and get position = file size
459 goToFileEnd();
460 int64_t fileSize = mFile.tellg();
461
462 // restore position
463 setReadPosition(oldReadPosition);
464 setWritePosition(oldWritePosition);
465 return fileSize;
466}
467
468road_time_t DbiteFile::getTimeMin() const
469{
470 return getHeader().TimeMin;
471}
472
473void DbiteFile::setTimeMin(road_time_t time)
474{
475 header().TimeMin = time;
476}
477
478road_time_t DbiteFile::getTimeMax() const
479{
480 return getHeader().TimeMax;
481}
482
483void DbiteFile::setTimeMax(road_time_t time)
484{
485 header().TimeMax = time;
486}
487
488hdfile_header_t::RecordCountT DbiteFile::getRecordCount() const
489{
490 return getHeader().NbRecords;
491}
492
493void DbiteFile::setRecordCount(hdfile_header_t::RecordCountT recourdCount)
494{
495 header().NbRecords = recourdCount;
496}
497
498bool DbiteFile::isVariableDataSize() const
499{
500 return hdfile_header_t::kVariableRecordSize == getRecordSize();
501}
502
503bool DbiteFile::readRecord(size_t recordIndex, road_time_t & time, road_timerange_t & timeRange, char * data, size_t & dataSize)
504{
505 LOG_DEBUG("reading record no. " << recordIndex);
506
507 if (isVariableDataSize()) {
508 LOG_ERROR("cannot read nth record in a variable");
509 throw DbiteException("cannot read nth record in a variable");
510 }
511
512 int64_t nthRecordPosition = getDataOffset() + recordIndex * (getRecordSize() + sizeof(road_time_t) + sizeof(road_timerange_t));
513 LOG_DEBUG(recordIndex << "th record position = " << nthRecordPosition);
514 if (getFileSize() < nthRecordPosition) {
515 LOG_WARN("wanted to read past the file end");
516 //throw DbiteException("wanted to read past the file end");
517 }
518 mFile.clear();
519 setReadPosition(nthRecordPosition);
520
521 return readRecord(time, timeRange, data, dataSize);
522}
523
524bool DbiteFile::readRecord(road_time_t & time, road_timerange_t & timeRange, char * buffer, size_t & bufferSize, const ReadDirection & direction)
525{
526 if (!buffer) {
527 LOG_WARN("data buffer must be a non-NULL pointer");
528 throw DbiteException("data buffer must be a non-NULL pointer");
529 }
530
531 return readRecordNoBufferCheck(time, timeRange, buffer, bufferSize, direction);
532}
533
534bool DbiteFile::readRecord(road_time_t & time, road_timerange_t & timeRange, char * buffer, const ReadDirection & direction)
535{
536 size_t bufferSize = getRecordSize();
537 return readRecord(time, timeRange, buffer, bufferSize, direction);
538}
539
540bool DbiteFile::readRecord(road_time_t & time, road_timerange_t & timeRange, const ReadDirection & direction)
541{
542 size_t bufferSize = 0;
543 return readRecordNoBufferCheck(time, timeRange, (char *) NULL, bufferSize, direction);
544}
545
546bool DbiteFile::readRecordNoBufferCheck(road_time_t & time, road_timerange_t & timeRange, char * buffer, size_t & bufferSize, const ReadDirection & direction)
547{
548 switch (direction) {
549 case ReadForward:
550 return readRecordForward(time, timeRange, buffer, bufferSize);
551 break;
552
553 case ReadBackward:
554 return readRecordBackward(time, timeRange, buffer, bufferSize);
555 break;
556
557 default:
558 assert(false && "wrong ReadDirection parameter");
559 return false;
560 }
561}
562
563bool DbiteFile::readRecordForward(road_time_t & time, road_timerange_t & timeRange, char * buffer, size_t & bufferSize)
564{
565 LOG_TRACE("reading record...");
566 checkFileOpen();
567
568 int64_t initialPosition = getReadPosition();
569 LOG_TRACE("initial position = " << initialPosition);
570
571 ////////////////////////////////////////
572 // read acquisition time
573 mFile.read((char *)(&time), sizeof(time));
574 if (!mFile) {
575 if (isEndOfFile()) {
576 bufferSize = 0;
577 return false;
578 }
579 LOG_ERROR("cannot read acquisition time");
580 throw DbiteException("cannot read acquisition time");
581 }
582
583 ////////////////////////////////////////
584 // read acquisition time range
585 read((char *)(&timeRange), sizeof(timeRange));
586
587 ////////////////////////////////////////
588 // get data and record size
589 size_t dataSize = 0;
590 size_t recordSize = sizeof(time) + sizeof(timeRange);
591 if (isVariableDataSize()) {
592 recordSize += 2 * sizeof(VariableDataSizeT);
593
594 // read record size
595 VariableDataSizeT readVarDataSize = 0;
596 read((char *)(&readVarDataSize), sizeof(VariableDataSizeT));
597 dataSize = static_cast<size_t>(readVarDataSize);
598 LOG_DEBUG("variable record size = " << dataSize);
599 } else {
600 dataSize = getRecordSize();
601 }
602 recordSize += dataSize;
603
604 ////////////////////////////////////////
605 // read/skip data
606 if (buffer) {
607 if (bufferSize < dataSize) {
608 LOG_WARN("buffer is smaller than the record size");
609 LOG_INFO("buffer size = " << bufferSize);
610 LOG_INFO("data size = " << dataSize);
611 throw DbiteException("buffer is smaller than the data size");
612 // TODO: don't throw exception, but read only as much data as possible
613 }
614
615 // read data
616 read(buffer, dataSize);
617
618 if (isVariableDataSize()) {
619 // read record size
620 VariableDataSizeT readVarDataSize = 0;
621 read((char *)(&readVarDataSize), sizeof(VariableDataSizeT));
622 size_t varDataSize = static_cast<size_t>(readVarDataSize);
623 LOG_TRACE("variable record size = " << varDataSize);
624
625 if (dataSize != varDataSize) {
626 LOG_WARN("corrupted data: data sizes differ");
627 LOG_INFO("data size (before) = " << dataSize);
628 LOG_INFO("data size (after) = " << varDataSize);
629 }
630 }
631 } else {
632 // skip data
633 setReadPosition(dataSize, ios_base::cur);
634 if (isVariableDataSize()) {
635 setReadPosition(dataSize, ios_base::cur);
636 }
637 }
638
639 ////////////////////////////////////////
640 // check how many bytes were read/skipped
641 int64_t positionDifference = getReadPosition() - initialPosition;
642 if (positionDifference != recordSize) {
643 LOG_WARN("should be read : " << recordSize << " [bytes]");
644 LOG_WARN("was actually read: " << positionDifference << " [bytes]");
645 }
646 return true;
647}
648
649bool DbiteFile::readRecordBackward(road_time_t & time, road_timerange_t & timeRange, char * buffer, size_t & bufferSize)
650{
651 int64_t initialPosition = getReadPosition();
652 LOG_TRACE("initial position = " << initialPosition);
653
654 size_t dataSize = 0;
655 size_t recordSize = sizeof(time) + sizeof(timeRange);
656 if (isVariableDataSize()) {
657 recordSize += 2 * sizeof(VariableDataSizeT);
658
659 // go back sizeof(VariableDataSizeT)
660 setReadPosition(initialPosition - sizeof(VariableDataSizeT));
661
662 // read VariableDataSizeT
663 VariableDataSizeT readVarDataSize = 0;
664 read((char *)(&readVarDataSize), sizeof(VariableDataSizeT));
665 dataSize = static_cast<size_t>(readVarDataSize);
666 LOG_DEBUG("variable record size = " << dataSize);
667 } else {
668 dataSize = getRecordSize();
669 }
670 // recordSize = sizeof(time) + sizeof(timeRange) + dataSize + [2 * sizeof(VariableDataSizeT)]
671 recordSize += dataSize;
672
673 // go back to the beginning of the previous record
674 setReadPosition(initialPosition - recordSize);
675
676 bool readResult = false;
677 try {
678 // read forward
679 readResult = readRecordForward(time, timeRange, buffer, bufferSize);
680 } catch (DbiteException & e) {
681 setReadPosition(initialPosition);
682 throw e;
683 }
684
685 // go back to the beginning of the previous record
686 setReadPosition(initialPosition - recordSize);
687 return readResult;
688}
689
690bool DbiteFile::writeRecord(const road_time_t & time, const road_timerange_t & timeRange, const char * data, const size_t dataSize)
691{
692 LOG_DEBUG("writing record:" << "\t"
693 << "time=" << time << "\t"
694 << "time range=" << timeRange << "\t"
695 << "data size=" << dataSize);
696 checkFileOpen();
697
698 if (isVariableDataSize()) {
699 if (dataSize > static_cast<size_t>(numeric_limits<VariableDataSizeT>::max())) {
700 LOG_ERROR("variable data size too big");
701 throw DbiteException("variable data size too big");
702 }
703 }
704
705 int64_t initialPosition = getWritePosition();
706 LOG_TRACE("getFileSize() = " << getFileSize());
707 LOG_TRACE("getWritePosition() = " << getWritePosition());
708 assert(initialPosition == getFileSize());
709
710 size_t writtenBytes = 0;
711 try {
712 // write acquisition time, acquisition time range, data
713 // if variable size, then write record size before and after data
714
715 write((const char *)(&time), sizeof(time));
716 writtenBytes += sizeof(time);
717
718 write((const char *)(&timeRange), sizeof(timeRange));
719 writtenBytes += sizeof(timeRange);
720
721 if (isVariableDataSize()) {
722 write((const char *)(&dataSize), sizeof(VariableDataSizeT));
723 writtenBytes += sizeof(VariableDataSizeT);
724 }
725 write((const char *)(data), dataSize);
726 writtenBytes += dataSize;
727
728 if (isVariableDataSize()) {
729 write((const char *)(&dataSize), sizeof(VariableDataSizeT));
730 writtenBytes += sizeof(VariableDataSizeT);
731 }
732 } catch (DbiteException & e) {
733 LOG_ERROR("Dbite exception: " << e.what());
734 LOG_INFO("restoring initial write position");
735
736 // on error, go back to record start
737 setWritePosition(- (int64_t) writtenBytes, ios_base::cur);
738 throw e;
739 }
740
741 // check how many bytes were written
742 int64_t finalPosition = getWritePosition();
743 int64_t positionDifference = finalPosition - initialPosition;
744 LOG_TRACE("position difference = " << positionDifference);
745 size_t totalRecordSize = dataSize + sizeof(time) + sizeof(timeRange);
746
747 setFileSize(finalPosition); // FIXME: possible loss of data, conversion int64_t -> FileSizeT
748 setRecordCount(getRecordCount() + 1);
749 setTimeMin(min(getTimeMin(), time));
750 setTimeMax(max(getTimeMax(), time));
751
752 if (positionDifference != totalRecordSize) {
753 LOG_WARN("should be written : " << totalRecordSize << " [bytes]");
754 LOG_WARN("was actually written: " << positionDifference << " [bytes]");
755 }
756 return true;
757}
758
759void DbiteFile::read(fstream::char_type * s, streamsize n)
760{
761 mFile.read(s, n);
762 if (!mFile) {
763 LOG_ERROR("cannot read data");
764 throw DbiteException("cannot read data");
765 }
766}
767
768void DbiteFile::write(const fstream::char_type * s, streamsize n)
769{
770 mFile.write(s, n);
771 if (!mFile) {
772 LOG_ERROR("cannot write data");
773 throw DbiteException("cannot write data");
774 }
775}
776
777bool DbiteFile::isEndOfFile()
778{
779 return mFile.eof();
780}
781
782void DbiteFile::checkFileOpen()
783{
784 if (!isOpen()) {
785 string errorMessage = "file is not open";
786 LOG_WARN(errorMessage);
787 throw DbiteException(errorMessage.c_str());
788 }
789}
790
791bool doesFileExist(const string & path)
792{
793 bool fileExist = false;
794 fstream f(path.c_str(), ios_base::in);
795 if (f.good()) {
796 fileExist = true;
797 }
798 f.close();
799 return fileExist;
800}
Note: See TracBrowser for help on using the repository browser.