GxStream.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_CORE_NAMESPACE_BEGIN()
 
class GxStreamReader;
//===========================================================================
//===========================================================================
class GxStream : public GxClassBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI宣言
    GX_RTTI_CLASS(GxStream, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxStream)
    // new, delete指定
    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::TEMPORARY)
 
    
    enum ATTRIBUTE
    {
        ATTRIBUTE_SEEKABLE = (1 << 0),                      
        ATTRIBUTE_CANCELED = (1 << 1)                       
    };
 
    static constexpr u32 COPY_TEMPORARY_BUFFER_SIZE = GxMath::VALUE_32K;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxStream(void) : _attribute(0){}
    ~GxStream(void) override { close(); }
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    virtual void close(void){}
    virtual u32  read(void* /*pDst*/, u32 /*size*/){ return 0; }
    virtual u32  write(const void* /*pSrc*/, u32 /*size*/){ return 0; }
    virtual void flush(void){}
    virtual u32 seek(s32 /*offset*/, GxFile::SEEK_TYPE /*seekType*/ = GxFile::SEEK_TYPE::BEGIN) { return 0; }
    
    u32 copy(GxStream& dst, u32 size);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    virtual u32  getPosition(void)          const   { return 0; }
    virtual void setSize(u32 /*length*/)    {}
    virtual u32  getSize(void)              const   { return 0; }
    virtual b32 isReadable(void)            const   { return true; }
    virtual b32 isWritable(void)            const   { return true; }
    virtual b32 isEnd(void)                 const   { return (getSize() == getPosition()); }
 
    GX_FORCE_INLINE s32 getRemainSize(void)     const   { return static_cast<s32>(getSize() - getPosition()); }
    GX_FORCE_INLINE b32 isCanceled(void)    const   { return getAttribute(ATTRIBUTE_CANCELED); }
 
    constexpr void setAttribute(ATTRIBUTE attribute) { _attribute |= attribute; }
    constexpr void clearAttribute(ATTRIBUTE attribute) { _attribute &= ~attribute; }
    GX_FORCE_INLINE b32 getAttribute(ATTRIBUTE attribute) const { return ((_attribute & attribute) != 0); }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    u32                 _attribute;                         
 
};
 
//===========================================================================
//===========================================================================
class GxFileStream : public GxStream
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI宣言
    GX_RTTI_CLASS(GxFileStream, GxStream)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxFileStream)
 
    
    static constexpr u32 CACHE_BUFFER_SIZE = GxMath::VALUE_64K;
 
    static u32 _readCacheBufferSize;
    static u32 _writeCacheBufferSize;   
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxFileStream(void);
    GxFileStream(GxFile* pFile, u32 offset = 0, u32 size = 0);
    ~GxFileStream(void) override;
        
    void initialize(GxFile* pFile, u32 offset = 0, u32 size = 0);
    void terminate(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    void close(void) override;
    u32 read(void* pDst, u32 size) override;
    u32 write(const void* pSrc, u32 size) override;
    void flush(void) override;
    u32 seek(s32 offset, GxFile::SEEK_TYPE seekType = GxFile::SEEK_TYPE::BEGIN) override;
 
private:
    b32 isHitCache(void) const;
    b32 readToCache(void);
    u32 readFromCache(void* pDst, u32 size);
 
    b32 isFlushCache(void) const;
    u32 writeToCache(const void* pSrc, u32 size);
    b32 flushCache(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    u32 getPosition(void)   const override;
    u32 getSize(void)       const override;
    b32 isReadable(void)    const override;
    b32 isWritable(void)    const override;
 
    GX_CSTR getFileName(void)       const;
    u32     getFilePosition(void)   const;
    u32     getFileOffset(void)     const;
 
    GX_FORCE_INLINE static void setConfig(u32 readBufferSize, u32 writeBufferSize)
    {
        _readCacheBufferSize = GxMath::getMax(CACHE_BUFFER_SIZE, readBufferSize);
        _writeCacheBufferSize = GxMath::getMax(CACHE_BUFFER_SIZE, writeBufferSize);
    }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxFile*             _pFile;                             
    u32                 _position;                          
    u32                 _offset;                            
    u32                 _size;                              
    void*               _pReadCacheBuffer;                  
    u32                 _readCachePosition;                 
    u32                 _readCacheSize;                     
    void*               _pWriteCacheBuffer;                 
    u32                 _writeCachePosition;                
    u32                 _writeCacheSize;                    
 
};
 
//===========================================================================
//===========================================================================
class GxMemoryStream : public GxStream
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI宣言
    GX_RTTI_CLASS(GxMemoryStream, GxStream)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxMemoryStream)
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxMemoryStream(GxAllocatorList::ALLOCATOR_TYPE allocatorType = GxAllocatorList::ALLOCATOR_TYPE::TEMPORARY);
    GxMemoryStream(GxAllocator* pAllocator);
    ~GxMemoryStream(void) override;
 
    b32 initialize(u32 size, GxMemory::ALIGNMENT alignment = GxMemory::ALIGNMENT::_16);
    b32 initialize(void* pBuffer, u32 size);
    b32 initialize(GxStream* pStream, u32 size = 0);
    void terminate(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    u32 read(void* pDst, u32 size) override;
    u32 write(const void* pSrc, u32 size) override;
    u32 seek(s32 offset, GxFile::SEEK_TYPE seekType = GxFile::SEEK_TYPE::BEGIN) override;
 
    void* reserve(u32 size);
    void  alignment(GxMemory::ALIGNMENT alignment);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_FORCE_INLINE u32 getPosition(void)               const override { return _position; }
    GX_FORCE_INLINE u32 getSize(void)                   const override { return _size; }
 
    GX_FORCE_INLINE b32 isReadable(void)                const override { return (_pBuffer != nullptr); }
    GX_FORCE_INLINE b32 isWritable(void)                const override { return (_pBuffer != nullptr); }
 
    constexpr void* getBuffer(void)                     const           { return _pBuffer; }
    GX_FORCE_INLINE void* getCurrent(void)              const           { return reinterpret_cast<u8*>(_pBuffer) + _position; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxAllocator*        _pAllocator;                        
    void*               _pBuffer;                           
    u32                 _size;                              
    u32                 _position;                          
    b32                 _isAllocateMemory;                  
 
};
 
//===========================================================================
//===========================================================================
class GxRingStream : public GxStream
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI宣言
    GX_RTTI_CLASS(GxRingStream, GxStream)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxRingStream)
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxRingStream(void);
    ~GxRingStream(void) override;
 
    b32 initialize(u32 size, GxAllocator* pAllocator = nullptr, GxMemory::ALIGNMENT alignment = GxMemory::ALIGNMENT::_16);
    b32 initialize(void* pBuffer, u32 size);
    void terminate(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    u32 read(void* pDst, u32 size) override;
    u32 write(const void* pSrc, u32 size) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_FORCE_INLINE u32 getSize(void) const override { return _size; }
 
    constexpr u32 getFreeSize(void) const   { return _size - _usedSize; }
    constexpr u32 getUsedSize(void) const   { return _usedSize; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxAllocator*        _pAllocator;                        
    void*               _pBuffer;                           
    u32                 _size;                              
    u32                 _readPosition;                      
    u32                 _writePosition;                     
    u32                 _usedSize;                          
 
};
 
//===========================================================================
//===========================================================================
class GxZlibReadStream : public GxStream
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI
    GX_RTTI_CLASS(GxZlibReadStream, GxStream)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxZlibReadStream)
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxZlibReadStream(void);
    ~GxZlibReadStream(void) override;
 
    b32 initialize(GxStreamReader* pStreamReader, u32 chunkSizeByte);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    u32 read(void* pDst, u32 size) override;
    u32 seek(s32 offset, GxFile::SEEK_TYPE seekType = GxFile::SEEK_TYPE::BEGIN) override;
 
    GX_FORCE_INLINE void* reserve(u32 /*size*/) { GX_ASSERT(false, "reserve is not impl."); return nullptr; }
    void  alignment(GxMemory::ALIGNMENT alignment);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_FORCE_INLINE u32 getPosition(void)   const override { return _position; }
    GX_FORCE_INLINE u32 getSize(void)       const override { return _size; }
 
    GX_FORCE_INLINE b32 isReadable(void)    const override { return (_pBuffer != nullptr); }
    GX_FORCE_INLINE b32 isWritable(void)    const override { return false; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxStreamReader*     _pStreamReader;                     
    void*               _pBuffer;                           
    void*               _pDecoderHandle;                    
    u32                 _size;                              
    u32                 _position;                          
    u32                 _encodeLevel;                       
    u32                 _encodeSize;                        
    u32                 _blockSize;                         
    u32                 _bufferPosition;                    
    b32                 _isFirstBlock;                      
 
};
 
GX_CORE_NAMESPACE_END()