cASNWriterRev.h

Go to the documentation of this file.

//
 
#ifndef _INC_cASNWriterRev_H
#define _INC_cASNWriterRev_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cASNReader.h"
#include "GrayCore/include/cBits.h"
#include "GrayCore/include/cTimeInt.h"
 
namespace GrayLib
{
        class cASNSet1;
        class cASNSets;
 
        class GRAYLIB_LINK cASNWriterRev : public cMemBlock
        {
 
        protected:
                BYTE* m_pOutCur;                
 
        protected:
                HRESULT WriteSetsRev(const cASNSets* pCur);
 
        public:
                cASNWriterRev(BYTE* pStart, size_t nLen)
                        : cMemBlock(pStart, nLen)
                        , m_pOutCur(pStart + nLen)              // End to start.
                {}
                cASNWriterRev(cMemBlock& m)
                        : cMemBlock(m)
                        , m_pOutCur(const_cast<BYTE*>((BYTE*)m.get_DataEnd()))          // End to start.
                {}
 
                size_t get_LenLeft() const
                {
                        ASSERT(this->IsValidPtr2(this->m_pOutCur));
                        return (size_t)cMem::Diff(this->m_pOutCur, this->get_DataBytes());
                }
                size_t get_LenWritten() const
                {
                        ASSERT(this->IsValidPtr2(this->m_pOutCur));
                        return (size_t)cMem::Diff(this->get_DataEnd(), m_pOutCur);
                }
 
                BYTE* get_OutPtr() const
                {
                        return m_pOutCur;               // Current write position. This Advances backwards via AddOut(x) or Write*().
                }
 
                void AddOut(size_t nSize)
                {
                        m_pOutCur -= nSize;
                        ASSERT(m_pOutCur >= get_DataBytes());
                }
 
                void WriteByteRaw(BYTE b)
                {
                        m_pOutCur--;
                        m_pOutCur[0] = b;
                        ASSERT(this->IsValidPtr(this->m_pOutCur));
                }
 
                HRESULT WriteByte(BYTE b);
 
                HRESULT WriteRawData(const void* pBuffer, size_t size);
 
                HRESULT WriteLengthCode(size_t len);
 
                HRESULT WriteTag(ASN_t nTagExpected, size_t len);
 
                HRESULT WriteTagNull();
 
                HRESULT WriteTagBlock(ASN_t nTag, const void* pBuffer, size_t nSizeBuffer);
 
                HRESULT WriteTagBoolean(bool bVal);
 
                HRESULT WriteTagInt(int iVal);
                HRESULT WriteTagInt(const BYTE* pData, size_t nSize, bool bNegativeOrNA);
                HRESULT WriteTagInt(const cBitArray& X, bool bNegativeOrNA = false);
 
                HRESULT WriteTagOID(const char* oid, size_t oid_len);
 
                HRESULT WriteTagStringPrintable(const char* text, StrLen_t text_len= k_StrLen_UNK);
 
                HRESULT WriteTagStringIA5(const char* text, StrLen_t text_len = k_StrLen_UNK);
 
                HRESULT WriteTagArrayBits(const BYTE* pBuffer, BIT_ENUM_t bits);
 
                HRESULT WriteTagArrayBytes(const BYTE* pBuffer, size_t size);
 
                HRESULT WriteTagTime(const cTimeUnits& Tu);
                HRESULT WriteTagTime(const cTimeInt& time, TZ_TYPE nTimeZoneOffset= TZ_LOCAL);
 
                HRESULT WriteSet1(const cASNSet1& s);
                HRESULT WriteSets(const cASNSets& rNames);
 
                HRESULT WriteExtensionList1(const cASNSet1* ext);
                HRESULT WriteExtensionList(const cASNSets& rExtensions);
 
                HRESULT WriteTagSeqAlg(const char* oid, size_t oid_len);
                HRESULT WriteTagSeqAlg2(const char* oid, size_t oid_len, BYTE* pSig, size_t size);
        };
}
 
#endif // _INC_cASNWriterRev_H