stream_reader.h

 
#ifndef __StreamReader_h__
#define __StreamReader_h__
 
#include "system/io/text_reader.h"
#include "system/text/string_builder.h"
#include "system/string.h"
 
#include "fwd.h"
#include <mutex>
 
namespace System { namespace IO {
 
    //fw
    class Stream;
 
    class ASPOSECPP_SHARED_CLASS StreamReader : public TextReader
    {
    public:
        ASPOSECPP_SHARED_API StreamReader(const SharedPtr<Stream>& stream);
        ASPOSECPP_SHARED_API StreamReader(const SharedPtr<Stream>& stream, bool detectEncodingFromByteOrderMarks);
        ASPOSECPP_SHARED_API StreamReader(const SharedPtr<Stream>& stream, const EncodingPtr& encoding);
        ASPOSECPP_SHARED_API StreamReader(const SharedPtr<Stream>& stream, const EncodingPtr& encoding, bool detectEncodingFromByteOrderMarks);
        ASPOSECPP_SHARED_API StreamReader(const SharedPtr<Stream>& stream, const EncodingPtr& encoding, bool detectEncodingFromByteOrderMarks, int bufferSize);
 
        ASPOSECPP_SHARED_API StreamReader(const System::String & path);
        ASPOSECPP_SHARED_API StreamReader(const System::String & path, bool detectEncodingFromByteOrderMarks);
        ASPOSECPP_SHARED_API StreamReader(const System::String & path, const EncodingPtr& encoding);
        ASPOSECPP_SHARED_API StreamReader(const System::String & path, const EncodingPtr& encoding, bool detectEncodingFromByteOrderMarks);
        ASPOSECPP_SHARED_API StreamReader(const System::String & path, const EncodingPtr& encoding, bool detectEncodingFromByteOrderMarks, int bufferSize);
 
        ASPOSECPP_SHARED_API ~StreamReader();
 
    private:
        void Init(const EncodingPtr& encoding, bool detectEncodingFromByteOrderMarks, int bufferSize);
 
    public:
        using TextReader::Dispose;
 
        virtual ASPOSECPP_SHARED_API int Peek() override;
        virtual ASPOSECPP_SHARED_API int Read() override;
        virtual ASPOSECPP_SHARED_API int Read(ArrayPtr<char_t> buffer, int index, int count) override;
        virtual ASPOSECPP_SHARED_API String ReadLine() override;
        virtual ASPOSECPP_SHARED_API String ReadToEnd() override;
        virtual ASPOSECPP_SHARED_API void Close() override;
 
        ASPOSECPP_SHARED_API bool get_EndOfStream();
        EncodingPtr get_CurrentEncoding() { return encoding; }
        SharedPtr<Stream> get_BaseStream() const { return base_stream; }
 
    protected:
        ASPOSECPP_SHARED_API void Dispose(bool disposing) override;
 
    private:
        int ReadBuffer();
        int ReadBufferCore(int cbEncoded);
 
        int DoChecks(int count);
        SharedPtr<Stream> base_stream;
 
        ArrayPtr<uint8_t> input_buffer;
 
        static ArrayPtr<uint8_t> input_buffer_recycle;
        std::mutex               input_buffer_recycle_lock;
 
        ArrayPtr<char_t> decoded_buffer;
        static ArrayPtr<char_t> decoded_buffer_recycle;
 
        EncodingPtr encoding;
        DecoderPtr decoder;
        Text::StringBuilder line_builder;
 
        int decoded_count;
 
        int pos;
 
        // The input buffer size.
        int buffer_size;
        
        int do_checks;
        bool mayBlock;
        bool foundCR;
        int FindNextEOL();
 
        static const int DefaultBufferSize = 1024;
        static const int DefaultFileBufferSize = 4096;
        static const int MinimumBufferSize = 128;
 
    protected:
#ifdef ASPOSE_GET_SHARED_MEMBERS
        virtual ASPOSECPP_SHARED_API void GetSharedMembers(System::Object::shared_members_type& result) const override;
#endif
 
#ifdef __DBG_FOR_EACH_MEMBER
    public:
        ASPOSECPP_SHARED_API void DBG_for_each_member(DBG::for_each_member_visitor &visitor) const override;
        const char* DBG_class_name() const override { return "StreamReader"; }
#endif
    };
 
}}
 
#endif