diff options
Diffstat (limited to 'source/core/stream.h')
| -rw-r--r-- | source/core/stream.h | 333 |
1 files changed, 333 insertions, 0 deletions
diff --git a/source/core/stream.h b/source/core/stream.h new file mode 100644 index 000000000..30d1cc992 --- /dev/null +++ b/source/core/stream.h @@ -0,0 +1,333 @@ +#ifndef CORE_LIB_STREAM_H +#define CORE_LIB_STREAM_H + +#include "Basic.h" + +namespace CoreLib +{ + namespace IO + { + using CoreLib::Basic::Exception; + using CoreLib::Basic::String; + using CoreLib::Basic::RefPtr; + + class IOException : public Exception + { + public: + IOException() + {} + IOException(const String & message) + : CoreLib::Basic::Exception(message) + { + } + }; + + class EndOfStreamException : public IOException + { + public: + EndOfStreamException() + {} + EndOfStreamException(const String & message) + : IOException(message) + { + } + }; + + enum class SeekOrigin + { + Start, End, Current + }; + + class Stream : public CoreLib::Basic::Object + { + public: + virtual Int64 GetPosition()=0; + virtual void Seek(SeekOrigin origin, Int64 offset)=0; + virtual Int64 Read(void * buffer, Int64 length) = 0; + virtual Int64 Write(const void * buffer, Int64 length) = 0; + virtual bool IsEnd() = 0; + virtual bool CanRead() = 0; + virtual bool CanWrite() = 0; + virtual void Close() = 0; + }; + + class BinaryReader + { + private: + RefPtr<Stream> stream; + inline void Throw(Int64 val) + { + if (val == 0) + throw IOException("read operation failed."); + } + public: + BinaryReader(RefPtr<Stream> stream) + { + this->stream = stream; + } + Stream * GetStream() + { + return stream.Ptr(); + } + void ReleaseStream() + { + stream.Release(); + } + template<typename T> + void Read(T * buffer, int count) + { + stream->Read(buffer, sizeof(T)*(Int64)count); + } + template<typename T> + void Read(T & buffer) + { + Throw(stream->Read(&buffer, sizeof(T))); + } + template<typename T> + void Read(List<T> & buffer) + { + int count = ReadInt32(); + buffer.SetSize(count); + Read(buffer.Buffer(), count); + } + void Read(String & buffer) + { + buffer = ReadString(); + } + int ReadInt32() + { + int rs; + Throw(stream->Read(&rs, sizeof(int))); + return rs; + } + short ReadInt16() + { + short rs; + Throw(stream->Read(&rs, sizeof(short))); + return rs; + } + Int64 ReadInt64() + { + Int64 rs; + Throw(stream->Read(&rs, sizeof(Int64))); + return rs; + } + float ReadFloat() + { + float rs; + Throw(stream->Read(&rs, sizeof(float))); + return rs; + } + double ReadDouble() + { + double rs; + Throw(stream->Read(&rs, sizeof(double))); + return rs; + } + char ReadChar() + { + char rs; + Throw(stream->Read(&rs, sizeof(char))); + return rs; + } + String ReadString() + { + int len = ReadInt32(); + char * buffer = new char[len+1]; + try + { + Throw(stream->Read(buffer, len)); + } + catch(IOException & e) + { + delete [] buffer; + throw e; + } + buffer[len] = 0; + return String::FromBuffer(buffer, len); + } + }; + + class BinaryWriter + { + private: + RefPtr<Stream> stream; + public: + BinaryWriter(RefPtr<Stream> stream) + { + this->stream = stream; + } + Stream * GetStream() + { + return stream.Ptr(); + } + template<typename T> + void Write(const T& val) + { + stream->Write(&val, sizeof(T)); + } + template<typename T> + void Write(T * buffer, int count) + { + stream->Write(buffer, sizeof(T)*(Int64)count); + } + template<typename T> + void Write(const List<T> & list) + { + Write(list.Count()); + stream->Write(list.Buffer(), sizeof(T)*list.Count()); + } + void Write(const String & str) + { + Write(str.Length()); + Write(str.Buffer(), str.Length()); + } + void ReleaseStream() + { + stream.Release(); + } + void Close() + { + stream->Close(); + } + }; + + enum class FileMode + { + Create, Open, CreateNew, Append + }; + + enum class FileAccess + { + Read = 1, Write = 2, ReadWrite = 3 + }; + + enum class FileShare + { + None, ReadOnly, WriteOnly, ReadWrite + }; + + class FileStream : public Stream + { + private: + FILE * handle; + FileAccess fileAccess; + bool endReached = false; + void Init(const CoreLib::Basic::String & fileName, FileMode fileMode, FileAccess access, FileShare share); + public: + FileStream(const CoreLib::Basic::String & fileName, FileMode fileMode = FileMode::Open); + FileStream(const CoreLib::Basic::String & fileName, FileMode fileMode, FileAccess access, FileShare share); + ~FileStream(); + public: + virtual Int64 GetPosition(); + virtual void Seek(SeekOrigin origin, Int64 offset); + virtual Int64 Read(void * buffer, Int64 length); + virtual Int64 Write(const void * buffer, Int64 length); + virtual bool CanRead(); + virtual bool CanWrite(); + virtual void Close(); + virtual bool IsEnd(); + }; + + class MemoryStream : public Stream + { + private: + CoreLib::List<unsigned char> writeBuffer; + CoreLib::ArrayView<unsigned char> readBuffer; + int ptr = 0; + bool isReadStream; + public: + MemoryStream() + { + isReadStream = false; + } + MemoryStream(unsigned char * mem, int length) + { + isReadStream = true; + readBuffer = MakeArrayView(mem, length); + } + MemoryStream(CoreLib::ArrayView<unsigned char> source) + { + isReadStream = true; + readBuffer = source; + } + virtual Int64 GetPosition() + { + return ptr; + } + virtual void Seek(SeekOrigin origin, Int64 offset) + { + if (origin == SeekOrigin::Start) + ptr = (int)offset; + else if (origin == SeekOrigin::End) + { + if (isReadStream) + ptr = readBuffer.Count() + (int)offset; + else + ptr = writeBuffer.Count() + (int)offset; + } + } + virtual Int64 Read(void * pbuffer, Int64 length) + { + Int64 i; + for (i = 0; i < length; i++) + { + if (ptr + i < readBuffer.Count()) + { + ((unsigned char*)pbuffer)[i] = readBuffer[(int)(ptr + i)]; + } + else + break; + } + return i; + } + virtual Int64 Write(const void * pbuffer, Int64 length) + { + writeBuffer.SetSize(ptr); + if (pbuffer) + writeBuffer.AddRange((unsigned char *)pbuffer, (int)length); + else + for (auto i = 0; i < length; i++) + writeBuffer.Add(0); + ptr = writeBuffer.Count(); + return length; + } + virtual bool CanRead() + { + return isReadStream; + } + virtual bool CanWrite() + { + return !isReadStream; + } + virtual void Close() + { + writeBuffer.SetSize(0); + writeBuffer.Compress(); + } + virtual bool IsEnd() + { + if (isReadStream) + return ptr >= readBuffer.Count(); + else + return ptr == writeBuffer.Count(); + } + void * GetBuffer() + { + if (isReadStream) + return readBuffer.Buffer(); + else + return writeBuffer.Buffer(); + } + int GetBufferSize() + { + if (isReadStream) + return readBuffer.Count(); + else + return writeBuffer.Count(); + } + }; + } +} + +#endif |