cASNReader.h

Go to the documentation of this file.

//
 
#ifndef _INC_cASNReader_H
#define _INC_cASNReader_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cASN.h"
#include "GrayCore/include/cTimeUnits.h"
 
namespace GrayLib
{
        class cBitArray;
        class cASNSequence;
        class cASNSets;
 
        class GRAYLIB_LINK cASNReader : public cMemBlock
        {
 
                typedef cMemBlock SUPER_t;
                friend class cASNBuf;
                friend class cASNSequence;
 
        protected:
                const BYTE* m_pInpCur;          
 
        protected:
                static HRESULT ReadStrUInt(const char* pData, size_t nSizeData, OUT UINT32& ruVal);
 
                HRESULT ReadLengthCode(OUT size_t& rSize);
                HRESULT ReadTag(ASN_t nTagExpected, OUT size_t& rSizeData);
 
        public:
                cASNReader(const BYTE* p = nullptr, size_t nSize = 0) noexcept
                        : cMemBlock(p, nSize)
                        , m_pInpCur(p)
                {
                }
                cASNReader(const cMemBlock& b) noexcept
                        : cMemBlock(b)
                        , m_pInpCur(b.get_DataBytes())
                {
                }
 
                static HRESULT ReadInt(const BYTE* pData, size_t nSizeData, OUT int& riVal);
                static HRESULT ReadTime(const char* pData, size_t nSizeData, bool bGeneral, OUT cTimeUnits& time);
 
                void SetBlock(const BYTE* p, size_t nSize)
                {
                        SUPER_t::SetBlock(const_cast<BYTE*>(p), nSize);
                        m_pInpCur = p;
                }
 
                size_t get_LenRead() const
                {
                        ASSERT(m_pInpCur >= get_DataBytes());
                        return (size_t)cMem::Diff(m_pInpCur, get_DataBytes());
                }
                size_t get_LenLeft() const
                {
                        ASSERT(m_pInpCur <= get_DataEnd());
                        return (size_t)cMem::Diff(get_DataEnd(), m_pInpCur);
                }
 
                bool isEOF() const
                {
                        return m_pInpCur >= get_DataEnd();
                }
                bool isEOFX() const
                {
                        return m_pInpCur == get_DataEnd();
                }
 
                const BYTE* get_InpCur() const noexcept
                {
                        return m_pInpCur;
                }
                BYTE* get_InpUnk() const
                {
                        return const_cast<BYTE*>(m_pInpCur);            // Current read position. This Advances.
                }
                BYTE get_InpByte() const
                {
                        ASSERT(!isEOF());
                        return m_pInpCur[0];
                }
 
                inline void AddInpCur(size_t nSize)
                {
                        m_pInpCur += nSize;
                        ASSERT(this->IsValidPtr2(m_pInpCur));   // NOT past end.
                }
                inline void AddInpCur(cMemBlock& r)
                {
                        AddInpCur(r.get_DataSize());
                }
                void ResetReader()
                {
                        m_pInpCur = get_DataBytes();
                }
 
                HRESULT ReadTagBlock(ASN_t nTagExpected, OUT cMemBlock& r);
 
                HRESULT ReadTagBuf(ASN_t nTagExpected, OUT cASNBuf& r);
 
                HRESULT ReadTagChild(ASN_t nTagExpected, OUT cASNReader& r);
 
                HRESULT ReadTagBoolean(OUT bool& rVal);
 
                HRESULT ReadTagInt(OUT int& riVal);
 
                HRESULT ReadTagArrayBits(OUT cASNBuf& bs);
 
                HRESULT ReadTagArrayBits0(OUT size_t& rSizeData);
 
                HRESULT ReadTagBigInt(OUT cBitArray& X);
 
                HRESULT ReadTagTime(OUT cTimeUnits& time);
 
                HRESULT ReadTagSequence(ASN_TYPE tag, cASNSequence& head);
 
                HRESULT ReadTagSeqAlg(OUT cASNBuf& alg, OUT cASNBuf& params);
 
                HRESULT ReadTagSeqAlgNull(OUT cASNBuf& alg);
 
                HRESULT ReadSets(OUT cASNSets& cur);
        };
}
 
#endif // _INC_cASNReader_H