CSink.cpp

Go to the documentation of this file.

#include "stdafx.h"

namespace AxPipe {
    bool
    CSink::DoSegWork(CSeg *pSeg) {
        bool fPropagate;                    // true if we propagate in band signals

        switch (pSeg->Type()) {
        case eSegTypeOpen:
            fPropagate = OutOpen();
            // Can't set this false before we've closed properly
            m_fIsOpen = true;
            return fPropagate;
            break;

        case eSegTypeFlush:
            return OutFlush();
            break;

        case eSegTypeClose:
            if (m_fIsOpen) {
                fPropagate = OutClose();
                // Can't set this false before we've closed properly
                m_fIsOpen = false;
            }
            return fPropagate;
            break;

        case eSegTypePlug:
            // Set the exit so we can end if it's a thread etc.
            OutPlug();                      // Call this class's Plug-function
            fPropagate = m_fExit = true;
            return fPropagate;
            break;

        case 0:
            if (!m_fIsOpen) {
                SetError(ERROR_CODE_NOTOPEN, ERROR_MSG_NOTOPEN);
                break;
            }
            if (pSeg->Len()) {
                // non-zero length data segment.
                // Out() will not be called with anything else. CFilter derived classes have slightly
                // different rules.
                Out(pSeg);
            } else {
                pSeg->Release();            // Ignore zero-length segments.
            }
            break;
        default:
            // It's an special/unknown segment type, call the handler (even with zero-length)
            // Note that we never auto propagate special segments, they are semantially similar
            // to normal data segments and must be manually Pump()'d by the implementation.
            OutSpecial(pSeg);
            break;
        }
        return false;
    }

    void
    CSink::Work() {
        CSeg *pSeg = m_pSeg;
        m_pSeg = NULL;

        (void)DoSegWork(pSeg);
    }

    void
    CSink::OutPlug() {
        Assert::OutputDebugStringF(_T("CSink::OutPlug() m_fExit=%d\n"), m_fExit);
    }

    CSeg *
    CSink::GetSeg(size_t cb)  {
        return new CSeg(cb);
    }

    void
    CSink::Signal(void *vId, void *p) {
    }

    longlong
    CSink::SizeMax() {
        return OutSizeMax();
    }

    void
    CSink::OutPump(CSeg *pSeg) {
        WorkStart();
        m_pSeg = pSeg;
        WorkSignal();
    }
    
    longlong
    CSink::OutSizeMax() {
        return -1;
    }
    
    CSeg *
    CSink::OutGetSeg(size_t cb) {
        return new CSeg(cb);
    }
    
    bool
    CSink::OutSignal(void *vId, void *p) {
        return false;
    }

    bool
    CSink::OutOpen() {
        return false;
    };
    
    bool
    CSink::OutFlush() {
        return false;
    };
    
    bool
    CSink::OutClose() {
        return false;
    };
    void
    CSink::OutSpecial(CSeg *pSeg) {
        pSeg->Release();
    }

    CSink::CSink() {
        m_pSeg = NULL;
        m_fIsOpen = false;
    }

    CSink::~CSink() {
        OutputDebugStringF(_T("CSink::~CSink() Initating... this=%p\n"), this);
        ASSCHK(m_fExit, _T("CSink::~CSink() called without Plug()"));
        if (CSeg::IsSeg(m_pSeg)) m_pSeg->Release();
        OutputDebugStringF(_T("CSink::~CSink() ...Done. this=%p\n"), this);
    }

    void
    CSink::AppendSink(CSink *pSink, bool fAutoDelete) {
        SetError(ERROR_CODE_GENERIC, _T("Attempt to append to a sink"));
    }

    void
    CSink::Sync() {
        WaitForIdle();
        // Do no more, this is a CSink - It's the end of the line.
    }

    void
    CSink::DestructSink() {
        OutputDebugString(_T("CSink::DestructSink()\n"));
    }
};

---