osb/source/core/StarIODevice.hpp
2023-06-20 14:33:09 +10:00

134 lines
3.7 KiB
C++

#ifndef STAR_IO_DEVICE_H
#define STAR_IO_DEVICE_H
#include "StarByteArray.hpp"
#include "StarString.hpp"
namespace Star {
STAR_CLASS(IODevice);
STAR_EXCEPTION(EofException, IOException);
enum class IOMode : uint8_t {
Closed = 0x0,
Read = 0x1,
Write = 0x2,
ReadWrite = 0x3,
Append = 0x4,
Truncate = 0x8,
};
IOMode operator|(IOMode a, IOMode b);
bool operator&(IOMode a, IOMode b);
// Should match SEEK_SET, SEEK_CUR, AND SEEK_END
enum IOSeek : uint8_t {
Absolute = 0,
Relative = 1,
End = 2
};
// Abstract Interface to a random access I/O device.
class IODevice {
public:
IODevice(IOMode mode = IOMode::Closed);
virtual ~IODevice();
// Do a read or write that may result in less data read or written than
// requested.
virtual size_t read(char* data, size_t len) = 0;
virtual size_t write(char const* data, size_t len) = 0;
virtual StreamOffset pos() = 0;
virtual void seek(StreamOffset pos, IOSeek mode = IOSeek::Absolute) = 0;
// Default implementation throws unsupported exception.
virtual void resize(StreamOffset size);
// Read / write from an absolute offset in the file without modifying the
// current file position. Default implementation stores the file position,
// then seeks and calls read/write partial, then restores the file position,
// and is not thread safe.
virtual size_t readAbsolute(StreamOffset readPosition, char* data, size_t len);
virtual size_t writeAbsolute(StreamOffset writePosition, char const* data, size_t len);
// Read and write fully, and throw an exception in every other case. The
// default implementations here will call the normal read or write, and if
// the full amount is not read will throw an exception.
virtual void readFull(char* data, size_t len);
virtual void writeFull(char const* data, size_t len);
virtual void readFullAbsolute(StreamOffset readPosition, char* data, size_t len);
virtual void writeFullAbsolute(StreamOffset writePosition, char const* data, size_t len);
// Default implementation throws exception if opening in a different mode
// than the current mode.
virtual void open(IOMode mode);
// Default implementation sets mode equal to Closed
virtual void close();
// Default implementation is a no-op
virtual void sync();
// Default implementation just prints address of generic IODevice
virtual String deviceName() const;
// Is the file position at the end of the file and there is no more to read?
// This is not the same as feof, which returns true after an unsuccesful read
// past the end, it should return true after succesfully reading the final
// byte. Default implementation returns pos() >= size();
virtual bool atEnd();
// Default is to store position, seek end, then restore position.
virtual StreamOffset size();
IOMode mode() const;
bool isOpen() const;
bool isReadable() const;
bool isWritable() const;
ByteArray readBytes(size_t size);
void writeBytes(ByteArray const& p);
ByteArray readBytesAbsolute(StreamOffset readPosition, size_t size);
void writeBytesAbsolute(StreamOffset writePosition, ByteArray const& p);
protected:
void setMode(IOMode mode);
IODevice(IODevice const&);
IODevice& operator=(IODevice const&);
private:
atomic<IOMode> m_mode;
};
inline IOMode operator|(IOMode a, IOMode b) {
return (IOMode)((uint8_t)a | (uint8_t)b);
}
inline bool operator&(IOMode a, IOMode b) {
return (uint8_t)a & (uint8_t)b;
}
inline IOMode IODevice::mode() const {
return m_mode;
}
inline bool IODevice::isOpen() const {
return m_mode != IOMode::Closed;
}
inline bool IODevice::isReadable() const {
return m_mode & IOMode::Read;
}
inline bool IODevice::isWritable() const {
return m_mode & IOMode::Write;
}
}
#endif