EuvStmServerBase.hpp

//
// Created by xiong on 2021/12/9.
//
 
#ifndef EMX_EuvStmServerBase_HPP
#define EMX_EuvStmServerBase_HPP
 
#include <list>
#include "EuvStreamInf.hpp"
 
namespace Emx {
    class EuvStmServerClientBase;
 
    class EuvStmServerHostBase {
    public:
 
        EuvStmServerHostBase(EuvStreamInf *stm) : m_stm(stm), m_buffer(nullptr) {}
 
        virtual ~EuvStmServerHostBase() { Destroy(); }
 
        ErrCodeE Create(EuvLoop &loop, const char *ip, uint16_t port, int maxClientNum, char *buffer, int32_t size);
 
        void Destroy();
 
        void DisConnectClient(EuvStmServerClientBase *client);
 
    protected:
 
        virtual EuvStmServerClientBase *OnAllocClient() = 0;
 
        virtual void OnClientConnect(EuvStmServerClientBase *client) = 0;
 
        virtual void OnClientDisConnect(EuvStmServerClientBase *client) = 0;
 
        virtual void OnRecv(EuvStmServerClientBase *client, char *data, int32_t size) = 0;
 
    private:
        EuvLoop *m_loop;
        EuvStreamInf *m_stm;
        char *m_buffer;
        int32_t m_size;
        std::list<EuvStmServerClientBase *> m_clientList;
    };
 
    class EuvStmServerClientBase {
    public:
        EuvStmServerClientBase(EuvStreamInf *stm, EuvStmServerHostBase *host) :
                m_stm(stm), m_host(host) {
            m_sendByPack = false;
            m_maxSend = -1;
            m_curSendSize = 0;
            m_curSendPack = 0;
        };
 
        virtual ~EuvStmServerClientBase() {};
 
        ErrCodeE Send(std::shared_ptr<std::string> &data);
 
        void SetMaxSendBuffer(bool sendByPack, int32_t maxSend) {
            m_sendByPack = sendByPack;
            m_maxSend = maxSend;
        };
 
        EuvStmServerHostBase *GetHost() { return m_host; }
 
        EuvStreamInf *GetStmInf() { return m_stm; }
 
        int32_t GetCurBufferedPack() { return m_curSendPack; }
 
        int32_t GetCurBufferedSize() { return m_curSendSize; }
 
        virtual void OnSendDone(ErrCodeE e, const char *buffer, int32_t size) {};
 
    private:
        void SendInc(int32_t size) {
            m_curSendPack++;
            m_curSendSize += size;
        }
 
        void SendDec(int32_t size) {
            m_curSendPack--;
            m_curSendSize -= size;
        }
 
        bool BufferOverflow() const {
            if (m_maxSend != -1) {
                return m_sendByPack ? m_curSendPack > m_maxSend : m_curSendSize > m_maxSend;
            }
            return false;
        }
 
        struct WriteReq {
            uv_write_t req;
            uv_buf_t buf;
            std::shared_ptr<std::string> data;
            EuvStmServerClientBase *obj;
        };
 
    private:
        bool m_sendByPack;//buffer size calculate by pack number or total stream size
        int32_t m_maxSend;//limited send buffer size
        int32_t m_curSendSize;//current stream size
        int32_t m_curSendPack;//current pack num
        EuvStreamInf *m_stm;
        EuvStmServerHostBase *m_host;
    };
}
 
#endif //EMX_EuvStmServerBase_HPP