cNetStream.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cNetStream_H
#define _INC_cNetStream_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cNetSocket.h"
#include "GrayCore/include/cStreamQueue.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cNetStream);
 
        class GRAYLIB_LINK cNetStream : public cStream, public cStreamStats
        {
 
                typedef cNetStream THIS_t;
                typedef cStream SUPER_t;
 
        public:
                cNetSocket m_Socket;            
                bool m_bAsync;                          
                bool m_bInpThrottled;           
                cStreamQueue m_bout;            
                cStreamQueue m_binp;            
                HRESULT m_hResultRx;    
 
        private:
                cThreadLockFast m_Lock;         
 
        protected:
#ifdef _WIN32
                virtual void OnClose()  // similar to MFC
                {
                        m_Socket.m_eState = SOCKETSTATE_Disconnected;
                        Close();
                }
#endif
 
        public:
                cNetStream(SOCKET hSocket = INVALID_SOCKET, bool bAsync = false, size_t nRxBufferLimit = (cStream::k_FILE_BLOCK_SIZE / 2));
                virtual ~cNetStream(void);
 
                bool isConnected() const
                {
                        return m_Socket.isConnected();
                }
                bool isConnecting() const noexcept
                {
                        return m_Socket.isConnecting();
                }
                bool isValidSocket() const noexcept
                {
                        return m_Socket.isValidSocket();
                }
 
                HASHCODE_t get_HashCode() const noexcept
                {
                        DEBUG_CHECK(isValidSocket());
                        return m_Socket.get_HashCode();
                }
 
                bool isInputDesired() const
                {
                        return(m_binp.get_GrowSizeChunk() > 0);
                }
                bool isInputEmpty() const
                {
                        if (!m_bAsync || m_bInpThrottled)
                        {
                                if (m_Socket.get_ReadReady() != 0)
                                        return false;
                        }
                        return m_binp.isEmptyQ();
                }
                bool isOutputEmpty() const
                {
                        return m_bout.isEmptyQ();
                }
                ITERATE_t get_InputQty() const
                {
                        if (!m_bAsync || m_bInpThrottled)
                        {
                                return m_Socket.get_ReadReady() + m_binp.get_ReadQty();
                        }
                        return m_binp.get_ReadQty();
                }
                ITERATE_t get_OutputQty() const
                {
                        return m_bout.get_ReadQty();
                }
 
                virtual HRESULT onEventWrite();         
                virtual HRESULT onEventRead();          
 
#ifdef _WIN32
                void OnEvent(WORD wEvent, LSTATUS wError);              
#endif
                HRESULT UpdateQWrite();
                HRESULT UpdateQRead();
 
                cStreamOutput* get_StreamOut()
                {
                        return &m_bout;
                }
                cStreamInput* get_StreamInp()
                {
                        return &m_binp;
                }
 
                // cStream
                virtual HRESULT WriteX(const void* pData, size_t nDataSize) override;
                virtual HRESULT ReadX(void* pData, size_t nDataSize) override;
                virtual size_t SetSeekSizeMin(size_t nSizeMin = k_FILE_BLOCK_SIZE) override;
                virtual STREAM_SEEKRET_t Seek(STREAM_OFFSET_t iOffset, SEEK_ORIGIN_TYPE eSeekOrigin) override;
                virtual void Close();
 
                void SetStateEstablished()
                {
                        m_StatInp.m_tLast.InitTimeNow();
                        m_Socket.SetStateEstablished();
                }
 
                UNITTEST_FRIEND(cNetStream);
        };
};
#endif // _INC_cNetStream_H