cStreamProgress.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cStreamProgress_H
#define _INC_cStreamProgress_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cOSHandle.h"
 
namespace Gray
{
        template< typename TYPE = STREAM_POS_t >
        class cStreamProgressT
        {
 
        public:
                TYPE m_nAmount;         
                TYPE m_nTotal;          
 
        public:
                cStreamProgressT(TYPE nAmount = 0, TYPE nTotal = 0)
                : m_nAmount(nAmount)
                , m_nTotal(nTotal)
                {
                }
                bool isComplete() const
                {
                        if (m_nTotal == 0) // no idea.
                                return true;
                        if (m_nAmount >= m_nTotal)
                                return true;
                        return false;
                }
                float get_PercentFloat() const
                {
                        if (m_nTotal == 0) // no idea.
                                return 0;
                        return (float)(((double)m_nAmount) / ((double)m_nTotal));
                }
                int get_PercentInt() const
                {
                        if (m_nTotal == 0) // no idea.
                                return 0;
                        return (int)((m_nAmount*100) / m_nTotal);
                }
                bool isValidPercent() const
                {
                        if (m_nTotal <= 0)      // no idea.
                                return false;
                        return(m_nAmount <= m_nTotal);
                }
                void InitZero()
                {
                        m_nAmount = 0;
                        m_nTotal = 0;   // 0 = i have no idea how big the total is.
                }
        };
 
        typedef cStreamProgressT<STREAM_POS_t> cStreamProgress;
 
        class GRAYCORE_LINK cStreamProgressF
        {
 
                friend class cStreamProgressChunk;
        private:
                // Stats
                float m_nTotal;                 
                float m_nAmount;        
 
        public:
                cStreamProgressF()
                : m_nTotal(1.0f)
                , m_nAmount(0.0f)
                {}
 
                void InitPercent()
                {
                        m_nTotal = 1.0f;        // of everything.
                        m_nAmount = 0.0f;
                }
#if 0
                void put_PercentComplete( float fComplete = 1.0f )
                {
                        m_nAmount = fComplete;  // indicate we are done.
                }
#endif
                float get_PercentComplete() const
                {
                        return m_nAmount;       // return value <= 1.0f
                }
                float get_PercentChunk() const
                {
                        return m_nTotal;
                }
        };
 
        class GRAYCORE_LINK cStreamProgressChunk
        {
 
        private:
                cStreamProgressF& m_Prog;
                cStreamProgressF m_ProgPrev;    
                int m_iChunk;   
                int m_iChunks;  
 
        public:
                cStreamProgressChunk(cStreamProgressF& prog, int iSubChunks, int iParentChunks = 1)
                : m_Prog(prog)
                , m_iChunk(0)
                , m_iChunks(iSubChunks)
                {
                        m_ProgPrev = m_Prog;
                        ASSERT(m_iChunks >= 0);
                        if (m_iChunks == 0)
                        {
                                prog.m_nTotal = 0;
                        }
                        else
                        {
                                prog.m_nTotal = (((float)iParentChunks) * prog.m_nTotal) / ((float)m_iChunks);  // MULDIV
                        }
                }
                ~cStreamProgressChunk()
                {
                        if (m_ProgPrev.m_nTotal >= 1.0f)
                        {
                                m_Prog.m_nTotal = m_Prog.m_nAmount = 1.0f;      // i have no parent. we are done.
                        }
                        else
                        {
                                m_Prog = m_ProgPrev;    // back out my changes and assume IncChunk() will be called from my parent.
                        }
                }
                void IncChunk(int iChunks = 1)
                {
                        m_iChunk += iChunks;
                        if (m_iChunk > m_iChunks)
                        {
                                // this really shouldn't happen!
                                m_iChunk = m_iChunks;
                        }
                        m_Prog.m_nAmount += iChunks * m_Prog.m_nTotal;
                }
        };
 
        struct GRAYCORE_LINK DECLSPEC_NOVTABLE IStreamProgressCallback
        {
 
                IGNORE_WARN_ABSTRACT(IStreamProgressCallback);
 
                virtual HRESULT _stdcall onProgressCallback(const cStreamProgress& progress)
                {
                        UNREFERENCED_REFERENCE(progress);
                        return S_OK;    // S_OK=just keep going.
                }
        };
};
 
#endif