CSeg.h

Go to the documentation of this file.

#pragma once
#ifndef AXPIPE_CSEG_H
#define AXPIPE_CSEG_H

#include "AxPipe.h"

namespace AxPipe {
class CSeg {
private:
    volatile LONG m_iRefCnt;                
    CRITICAL_SECTION m_CritSect;            

    void *m_pvBuf;                          
    size_t m_cbBuf;                         
    CSeg *m_pMom;                           
    bool m_fOwnPtr;                         
    bool m_fReadOnly;                       
    int m_iType;                            

    size_t m_cbOff;                         
    size_t m_cbLen;                         

    void Init(size_t cbBuf, void *pvBuf, bool fReadOnly, int iType);

    CSeg& operator=(CSeg& rhs);

public:
    CSeg(size_t cbBuf = 0, void *pvBuf = NULL, bool fReadOnly = false);

    CSeg(size_t cbBuf, const void *pvBuf);

    CSeg(const void *pvBuf, size_t cbLen, size_t cbGrowBuf = 0);

    virtual ~CSeg();
    
    unsigned char *Ptr();                   
    const unsigned char *PtrRd();           
    unsigned char *PtrWr();                 
    void *PtrRelease();                     
    size_t Size(void);                      
    size_t Len(void);                       
    CSeg *Len(size_t cbLen);                
    CSeg *Writeable();                      
    CSeg *Drop(size_t cbOff);               
    CSeg *AddRef();                         
    int Release();                          
    int Type();                             
    CSeg *SetType(int iType);               
    static bool IsSeg(CSeg *pSeg);          
    CSeg *Clone();                          
    static void *ClassId();                 
    virtual void *RTClassId();              
};

template<class T> class Auto_Seg {
private:
    T *m_p;                                 

    inline void Release() {
        if (m_p) {
            m_p->Release();
        }
    }
public:
    inline Auto_Seg(T *p = NULL) {
        m_p = p;
    }

    inline ~Auto_Seg() {
        Release();
    }
    
    inline Auto_Seg<T>& operator=(T *p) {
        Release();
        m_p = p;
        return *this;
    }
    
    inline Auto_Seg<T>& operator=(T& rhs) {
        rhs.AddRef();
        return *this = &rhs;
    }
    
    inline Auto_Seg<T>& operator=(Auto_Seg<T>& rhs) {
        if ((T *)rhs) {
            rhs->AddRef();
        }
        return *this = rhs.m_p;
    }
    
    inline operator T*() {
        return m_p;
    }
    
    inline T* operator ->() {
        return m_p;
    }
    
    inline T* get() {
        return m_p;
    }
    
    inline T* release() {
        T *p = m_p;
        m_p = NULL;
        return p;
    }
};
typedef Auto_Seg<CSeg> CAutoSeg;

}; // namespace AxPipe
#endif AXPIPE_CERROR_H

---