CSeg.cpp

Go to the documentation of this file.

#include "stdafx.h"

namespace AxPipe {
    void
    CSeg::Init(size_t cbBuf, void *pvBuf, bool fReadOnly, int iType) {
        InitializeCriticalSection(&m_CritSect);
        m_iType = iType;
        m_pMom = NULL;
        m_fReadOnly = fReadOnly;
        if (m_cbLen = m_cbBuf = cbBuf) {
            if (!(m_fOwnPtr = (pvBuf == NULL))) {
                m_pvBuf = pvBuf;
            } else {
                m_pvBuf = new unsigned char[m_cbBuf];
            }
        } else {
            m_fOwnPtr = false;
            m_pvBuf = NULL;
        }
        m_cbOff = 0;
        m_iRefCnt = 1;
    }

    CSeg&
    CSeg::operator=(CSeg& rhs) {

        EnterCriticalSection(&m_CritSect);

        // Here we should have some check for assignment to non-empty lhs
        // and clear that. We don't implement that right now.
        m_pMom = &rhs;
        m_pvBuf = rhs.m_pvBuf;
        m_cbBuf = rhs.m_cbBuf;
        m_cbLen = rhs.m_cbLen;
        m_cbOff = rhs.m_cbOff;
        m_fReadOnly = rhs.m_fReadOnly;
        m_fOwnPtr = false;                  // A copy can never own the buffer.

        LeaveCriticalSection(&m_CritSect);

        rhs.AddRef();
        return *this;
    }

    CSeg::CSeg(size_t cbBuf, void *pvBuf, bool fReadOnly) {
        Init(cbBuf, pvBuf, fReadOnly, 0);
    }

    CSeg::CSeg(size_t cbBuf, const void *pvBuf) {
        Init(cbBuf, (void *)pvBuf, true, 0);
    }

    CSeg::CSeg(const void *pvBuf, size_t cbLen, size_t cbGrowBuf) {
        Init(cbLen + cbGrowBuf, NULL, false, 0);
        
        // Decrease length to the valid part.
        m_cbLen = cbLen;
        
        // Initialize the allocated buffer with the data provided
        CopyMemory(m_pvBuf, pvBuf, cbLen);
    }

    CSeg::~CSeg() {
        if (m_iRefCnt) {
            MessageBox(NULL, _T("CSeg::~CSeg() bad call or double-delete"), _T("http://www.axondata.se"), MB_OK);
        } else {
            if (m_pMom) {
                m_pMom->Release();
            } else if (m_pvBuf && m_fOwnPtr) {
                delete m_pvBuf;
                m_pvBuf = NULL;
            }
        }
        DeleteCriticalSection(&m_CritSect);
    }
    
    unsigned char *
    CSeg::Ptr() {
        // m_pvBuf is only initialized in the constructor, so this is thread-safe
        return (unsigned char *)m_pvBuf;
    }

    const unsigned char *
    CSeg::PtrRd() {
        const unsigned char *r;
        EnterCriticalSection(&m_CritSect); {
            r = &((const unsigned char *)m_pvBuf)[m_cbOff];
        } LeaveCriticalSection(&m_CritSect);
        return r;
    }

    unsigned char *
    CSeg::PtrWr() {
        // m_fReadOnly is only initialized in the constructor, thus thread-safe
        return m_fReadOnly ? NULL : (unsigned char *)(PtrRd());
    }

    void *
    CSeg::PtrRelease() {
        // Return a buffer that is free to use. 
        void *p;
        EnterCriticalSection(&m_CritSect); {
            if (!m_fOwnPtr || (m_iRefCnt > 1) || m_pMom || m_cbOff) {
                if (p = new unsigned char[Len()]) {
                    memcpy(p, PtrRd(), Len());
                }
            } else {
                p = &((char *)m_pvBuf)[m_cbOff];
                m_pvBuf = NULL;
            }
        } LeaveCriticalSection(&m_CritSect);

        Release();
        return p;
    }
    
    size_t
    CSeg::Size(void) {
        size_t s;
        EnterCriticalSection(&m_CritSect); {
            s = m_cbBuf - m_cbOff;
        } LeaveCriticalSection(&m_CritSect);
        return s;
    }
    
    size_t
    CSeg::Len(void) {
        size_t l;
        EnterCriticalSection(&m_CritSect); {
            l = m_cbLen - m_cbOff;
        } LeaveCriticalSection(&m_CritSect);
        return l;
    }
    
    CSeg *
    CSeg::Len(size_t cbLen) {
        EnterCriticalSection(&m_CritSect); {
            m_cbLen = cbLen + m_cbOff;
        } LeaveCriticalSection(&m_CritSect);
        return this;
    }

    CSeg *
    CSeg::Writeable() {
        if (m_fReadOnly) {
            CSeg *pWriteable;
            EnterCriticalSection(&m_CritSect); {
                pWriteable = new CSeg(Len());
                memcpy(pWriteable->PtrWr(), PtrRd(), Len());
            } LeaveCriticalSection(&m_CritSect);
            return pWriteable;
        } else {
            return AddRef();
        }
    }
    
    CSeg *
    CSeg::Drop(size_t cbOff) {
        EnterCriticalSection(&m_CritSect); {
            m_cbOff += cbOff;
        } LeaveCriticalSection(&m_CritSect);
        return this;
    }

    CSeg *
    CSeg::AddRef() {
        // II makes it thread-safe
        InterlockedIncrement(&m_iRefCnt);
        return this;
    }

    int
    CSeg::Release() {
       LONG i = InterlockedDecrement(&m_iRefCnt);
        if (i == 0) {
            // This is why you must *never* reference a CSeg* after calling Release()
            // This is also why you must *never* delete  CSeg manually, nor allocate
            // one as auto or static.
            delete this;
        }
        return i;
    }

    int
    CSeg::Type() {
        // m_iType should only be set in construction, thus thread-safe
        return m_iType;
    }
    
    CSeg *
    CSeg::SetType(int iType) {
        m_iType = iType;
        return this;
    }
    
    bool
    CSeg::IsSeg(CSeg *pSeg) {
        return (pSeg != NULL && !pSeg->Type());
    }

    CSeg *
    CSeg::Clone() {
        // The operator= handles thread-issues
        return &(*new CSeg = *this);
    }

    void *
    CSeg::ClassId() {
        static int i;
        return &i;
    }

    void *
    CSeg::RTClassId() {
        return ClassId();
    }
};

---