Mirrors/bx
1
0
Fork 0
mirror of https://github.com/bkaradzic/bx.git synced 2026-02-18 04:53:06 +01:00
Code Issues Packages Projects Releases Wiki Activity

Improved reader/writer error handling.

Browse Source
This commit is contained in:
Branimir Karadžić
2016-01-31 15:59:51 -08:00
parent d1dd372215
commit a8e00d509c
2 changed files with 215 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files

108
include/bx/error.h Normal file
View File

@@ -0,0 +1,108 @@
/*
* Copyright 2010-2016 Branimir Karadzic. All rights reserved.
* License: https://github.com/bkaradzic/bx#license-bsd-2-clause
*/
#ifndef BX_ERROR_H_HEADER_GUARD
#define BX_ERROR_H_HEADER_GUARD
#include "bx.h"
#define BX_ERROR_SET(_ptr, _result, _msg) \
BX_MACRO_BLOCK_BEGIN \
BX_TRACE("Error %d: %s", _result.code, "" _msg); \
_ptr->setError(_result, "" _msg); \
BX_MACRO_BLOCK_END
#define BX_ERROR_SCOPE(_ptr) \
const bx::Error tmpError /* It should not be used directly! */; \
_ptr = NULL == _ptr ? const_cast<bx::Error*>(&tmpError) : _ptr; \
bx::ErrorScope bxErrorScope(const_cast<bx::Error*>(&tmpError))
#define BX_ERROR_RESULT(_err, _code) \
BX_STATIC_ASSERT(_code != 0, "ErrorCode 0 is reserved!"); \
static const bx::ErrorResult _err = { _code }
namespace bx
{
///
struct ErrorResult
{
uint32_t code;
};
///
class Error
{
BX_CLASS(Error
, NO_COPY
, NO_ASSIGNMENT
);
public:
Error()
: m_code(0)
{
}
void setError(ErrorResult _errorResult, const char* _msg)
{
BX_CHECK(0 != _errorResult.code, "Invalid ErrorResult passed to setError!");
if (!isOk() )
{
return;
}
m_code = _errorResult.code;
m_msg = _msg;
}
bool isOk() const
{
return 0 == m_code;
}
ErrorResult get() const
{
ErrorResult result = { m_code };
return result;
}
bool operator==(ErrorResult _rhs) const
{
return _rhs.code == m_code;
}
private:
const char* m_msg;
uint32_t m_code;
};
///
class ErrorScope
{
BX_CLASS(ErrorScope
, NO_COPY
, NO_ASSIGNMENT
);
public:
ErrorScope(Error* _err)
: m_err(_err)
{
BX_CHECK(NULL != _err, "_err can't be NULL");
}
~ErrorScope()
{
BX_CHECK(m_err->isOk(), "Error: %d", m_err->get().code);
}
private:
Error* m_err;
};
} // namespace bx
#endif // BX_ERROR_H_HEADER_GUARD

158
include/bx/readerwriter.h
View File

@@ -12,6 +12,7 @@
#include "bx.h"
#include "allocator.h"
#include "error.h"
#include "uint32_t.h"
#if BX_COMPILER_MSVC_COMPATIBLE
@@ -22,6 +23,10 @@
# define ftello64 ftello
#endif // BX_
BX_ERROR_RESULT(BX_ERROR_READERWRITER_OPEN, BX_MAKEFOURCC('R', 'W', 0, 1) );
BX_ERROR_RESULT(BX_ERROR_READERWRITER_READ, BX_MAKEFOURCC('R', 'W', 0, 2) );
BX_ERROR_RESULT(BX_ERROR_READERWRITER_WRITE, BX_MAKEFOURCC('R', 'W', 0, 3) );
namespace bx
{
struct Whence
@@ -37,7 +42,7 @@ namespace bx
struct BX_NO_VTABLE ReaderI
{
virtual ~ReaderI() = 0;
virtual int32_t read(void* _data, int32_t _size) = 0;
virtual int32_t read(void* _data, int32_t _size, Error* _err) = 0;
};
inline ReaderI::~ReaderI()
@@ -47,7 +52,7 @@ namespace bx
struct BX_NO_VTABLE WriterI
{
virtual ~WriterI() = 0;
virtual int32_t write(const void* _data, int32_t _size) = 0;
virtual int32_t write(const void* _data, int32_t _size, Error* _err) = 0;
};
inline WriterI::~WriterI()
@@ -65,40 +70,45 @@ namespace bx
}
/// Read data.
inline int32_t read(ReaderI* _reader, void* _data, int32_t _size)
inline int32_t read(ReaderI* _reader, void* _data, int32_t _size, Error* _err = NULL)
{
return _reader->read(_data, _size);
BX_ERROR_SCOPE(_err);
return _reader->read(_data, _size, _err);
}
/// Write value.
template<typename Ty>
inline int32_t read(ReaderI* _reader, Ty& _value)
inline int32_t read(ReaderI* _reader, Ty& _value, Error* _err = NULL)
{
BX_ERROR_SCOPE(_err);
BX_STATIC_ASSERT(BX_TYPE_IS_POD(Ty) );
return _reader->read(&_value, sizeof(Ty) );
return _reader->read(&_value, sizeof(Ty), _err);
}
/// Read value and converts it to host endianess. _fromLittleEndian specifies
/// underlying stream endianess.
template<typename Ty>
inline int32_t readHE(ReaderI* _reader, Ty& _value, bool _fromLittleEndian)
inline int32_t readHE(ReaderI* _reader, Ty& _value, bool _fromLittleEndian, Error* _err = NULL)
{
BX_STATIC_ASSERT(BX_TYPE_IS_POD(Ty) );
Ty value;
int32_t result = _reader->read(&value, sizeof(Ty) );
int32_t result = _reader->read(&value, sizeof(Ty), _err);
_value = toHostEndian(value, _fromLittleEndian);
return result;
}
/// Write data.
inline int32_t write(WriterI* _writer, const void* _data, int32_t _size)
inline int32_t write(WriterI* _writer, const void* _data, int32_t _size, Error* _err = NULL)
{
return _writer->write(_data, _size);
BX_ERROR_SCOPE(_err);
return _writer->write(_data, _size, _err);
}
/// Write repeat the same value.
inline int32_t writeRep(WriterI* _writer, uint8_t _byte, int32_t _size)
inline int32_t writeRep(WriterI* _writer, uint8_t _byte, int32_t _size, Error* _err = NULL)
{
BX_ERROR_SCOPE(_err);
const uint32_t tmp0 = uint32_sels(64 - _size, 64, _size);
const uint32_t tmp1 = uint32_sels(256 - _size, 256, tmp0);
const uint32_t blockSize = uint32_sels(1024 - _size, 1024, tmp1);
@@ -108,7 +118,7 @@ namespace bx
int32_t size = 0;
while (0 < _size)
{
int32_t bytes = write(_writer, temp, uint32_min(blockSize, _size) );
int32_t bytes = write(_writer, temp, uint32_min(blockSize, _size), _err);
size += bytes;
_size -= bytes;
}
@@ -118,29 +128,32 @@ namespace bx
/// Write value.
template<typename Ty>
inline int32_t write(WriterI* _writer, const Ty& _value)
inline int32_t write(WriterI* _writer, const Ty& _value, Error* _err = NULL)
{
BX_ERROR_SCOPE(_err);
BX_STATIC_ASSERT(BX_TYPE_IS_POD(Ty) );
return _writer->write(&_value, sizeof(Ty) );
return _writer->write(&_value, sizeof(Ty), _err);
}
/// Write value as little endian.
template<typename Ty>
inline int32_t writeLE(WriterI* _writer, const Ty& _value)
inline int32_t writeLE(WriterI* _writer, const Ty& _value, Error* _err = NULL)
{
BX_ERROR_SCOPE(_err);
BX_STATIC_ASSERT(BX_TYPE_IS_POD(Ty) );
Ty value = toLittleEndian(_value);
int32_t result = _writer->write(&value, sizeof(Ty) );
int32_t result = _writer->write(&value, sizeof(Ty), _err);
return result;
}
/// Write value as big endian.
template<typename Ty>
inline int32_t writeBE(WriterI* _writer, const Ty& _value)
inline int32_t writeBE(WriterI* _writer, const Ty& _value, Error* _err = NULL)
{
BX_ERROR_SCOPE(_err);
BX_STATIC_ASSERT(BX_TYPE_IS_POD(Ty) );
Ty value = toBigEndian(_value);
int32_t result = _writer->write(&value, sizeof(Ty) );
int32_t result = _writer->write(&value, sizeof(Ty), _err);
return result;
}
@@ -198,34 +211,36 @@ namespace bx
struct BX_NO_VTABLE FileReaderI : public ReaderSeekerI
{
virtual int32_t open(const char* _filePath) = 0;
virtual int32_t close() = 0;
virtual bool open(const char* _filePath, Error* _err) = 0;
virtual void close() = 0;
};
struct BX_NO_VTABLE FileWriterI : public WriterSeekerI
{
virtual int32_t open(const char* _filePath, bool _append = false) = 0;
virtual int32_t close() = 0;
virtual bool open(const char* _filePath, bool _append, Error* _err) = 0;
virtual void close() = 0;
};
inline int32_t open(FileReaderI* _reader, const char* _filePath)
inline bool open(FileReaderI* _reader, const char* _filePath, Error* _err = NULL)
{
return _reader->open(_filePath);
BX_ERROR_SCOPE(_err);
return _reader->open(_filePath, _err);
}
inline int32_t close(FileReaderI* _reader)
inline void close(FileReaderI* _reader)
{
return _reader->close();
_reader->close();
}
inline int32_t open(FileWriterI* _writer, const char* _filePath, bool _append = false)
inline bool open(FileWriterI* _writer, const char* _filePath, bool _append = false, Error* _err = NULL)
{
return _writer->open(_filePath, _append);
BX_ERROR_SCOPE(_err);
return _writer->open(_filePath, _append, _err);
}
inline int32_t close(FileWriterI* _writer)
inline void close(FileWriterI* _writer)
{
return _writer->close();
_writer->close();
}
struct BX_NO_VTABLE MemoryBlockI
@@ -332,8 +347,10 @@ namespace bx
return m_pos;
}
virtual int32_t write(const void* /*_data*/, int32_t _size) BX_OVERRIDE
virtual int32_t write(const void* /*_data*/, int32_t _size, Error* _err) BX_OVERRIDE
{
BX_CHECK(NULL != _err, "Reader/Writer interface calling functions must handle errors.");
int32_t morecore = int32_t(m_pos - m_top) + _size;
if (0 < morecore)
@@ -344,6 +361,10 @@ namespace bx
int64_t reminder = m_top-m_pos;
int32_t size = uint32_min(_size, int32_t(reminder > INT32_MAX ? INT32_MAX : reminder) );
m_pos += size;
if (size != _size)
{
BX_ERROR_SET(_err, BX_ERROR_READERWRITER_WRITE, "SizerWriter: write truncated.");
}
return size;
}
@@ -386,12 +407,18 @@ namespace bx
return m_pos;
}
virtual int32_t read(void* _data, int32_t _size) BX_OVERRIDE
virtual int32_t read(void* _data, int32_t _size, Error* _err) BX_OVERRIDE
{
BX_CHECK(NULL != _err, "Reader/Writer interface calling functions must handle errors.");
int64_t reminder = m_top-m_pos;
int32_t size = uint32_min(_size, int32_t(reminder > INT32_MAX ? INT32_MAX : reminder) );
memcpy(_data, &m_data[m_pos], size);
m_pos += size;
if (size != _size)
{
BX_ERROR_SET(_err, BX_ERROR_READERWRITER_READ, "MemoryReader: read truncated.");
}
return size;
}
@@ -452,8 +479,10 @@ namespace bx
return m_pos;
}
virtual int32_t write(const void* _data, int32_t _size) BX_OVERRIDE
virtual int32_t write(const void* _data, int32_t _size, Error* _err) BX_OVERRIDE
{
BX_CHECK(NULL != _err, "Reader/Writer interface calling functions must handle errors.");
int32_t morecore = int32_t(m_pos - m_size) + _size;
if (0 < morecore)
@@ -468,6 +497,10 @@ namespace bx
memcpy(&m_data[m_pos], _data, size);
m_pos += size;
m_top = int64_max(m_top, m_pos);
if (size != _size)
{
BX_ERROR_SET(_err, BX_ERROR_READERWRITER_WRITE, "MemoryWriter: write truncated.");
}
return size;
}
@@ -509,16 +542,23 @@ namespace bx
{
}
virtual int32_t open(const char* _filePath) BX_OVERRIDE
virtual bool open(const char* _filePath, Error* _err) BX_OVERRIDE
{
BX_CHECK(NULL != _err, "Reader/Writer interface calling functions must handle errors.");
m_file = fopen(_filePath, "rb");
return NULL == m_file;
if (NULL == m_file)
{
BX_ERROR_SET(_err, BX_ERROR_READERWRITER_OPEN, "CrtFileReader: Failed to open file.");
return false;
}
return true;
}
virtual int32_t close() BX_OVERRIDE
virtual void close() BX_OVERRIDE
{
fclose(m_file);
return 0;
}
virtual int64_t seek(int64_t _offset = 0, Whence::Enum _whence = Whence::Current) BX_OVERRIDE
@@ -527,9 +567,18 @@ namespace bx
return ftello64(m_file);
}
virtual int32_t read(void* _data, int32_t _size) BX_OVERRIDE
virtual int32_t read(void* _data, int32_t _size, Error* _err) BX_OVERRIDE
{
return (int32_t)fread(_data, 1, _size, m_file);
BX_CHECK(NULL != _err, "Reader/Writer interface calling functions must handle errors.");
int32_t size = fread(_data, 1, _size, m_file);
if (size != _size)
{
BX_ERROR_SET(_err, BX_ERROR_READERWRITER_READ, "CrtFileReader: read failed.");
return size >= 0 ? size : 0;
}
return size;
}
private:
@@ -548,24 +597,22 @@ namespace bx
{
}
virtual int32_t open(const char* _filePath, bool _append = false) BX_OVERRIDE
virtual bool open(const char* _filePath, bool _append, Error* _err) BX_OVERRIDE
{
if (_append)
m_file = fopen(_filePath, _append ? "ab" : "wb");
if (NULL == m_file)
{
m_file = fopen(_filePath, "ab");
}
else
{
m_file = fopen(_filePath, "wb");
BX_ERROR_SET(_err, BX_ERROR_READERWRITER_OPEN, "CrtFileWriter: Failed to open file.");
return false;
}
return NULL == m_file;
return true;
}
virtual int32_t close() BX_OVERRIDE
virtual void close() BX_OVERRIDE
{
fclose(m_file);
return 0;
}
virtual int64_t seek(int64_t _offset = 0, Whence::Enum _whence = Whence::Current) BX_OVERRIDE
@@ -574,9 +621,18 @@ namespace bx
return ftello64(m_file);
}
virtual int32_t write(const void* _data, int32_t _size) BX_OVERRIDE
virtual int32_t write(const void* _data, int32_t _size, Error* _err) BX_OVERRIDE
{
return (int32_t)fwrite(_data, 1, _size, m_file);
BX_CHECK(NULL != _err, "Reader/Writer interface calling functions must handle errors.");
int32_t size = fwrite(_data, 1, _size, m_file);
if (size != _size)
{
BX_ERROR_SET(_err, BX_ERROR_READERWRITER_WRITE, "CrtFileWriter: write failed.");
return size >= 0 ? size : 0;
}
return size;
}
private: