cTextPos.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cTextPos_H
#define _INC_cTextPos_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cStreamProgress.h"
#include "StrT.h"
 
namespace Gray
{
        class GRAYCORE_LINK cTextPos
        {
 
        public:
                static const cTextPos k_Invalid;        
                static const cTextPos k_Zero;           
 
        protected:
                STREAM_POS_t m_lOffset;         
                ITERATE_t m_iLineNum;           
                StrLen_t m_iColNum;                     
                // m_iLineNum = -1 or -2 can be used to indicate errors.
 
        public:
                cTextPos(STREAM_POS_t lOffset = (STREAM_POS_t)k_ITERATE_BAD, ITERATE_t iLineNum = k_ITERATE_BAD, StrLen_t iColNum = k_StrLen_UNK) noexcept
                        : m_lOffset(lOffset)
                        , m_iLineNum(iLineNum)
                        , m_iColNum(iColNum)
                {
                }
 
                void InitTop() noexcept
                {
                        m_lOffset = 0;
                        m_iLineNum = 0;
                        m_iColNum = 0;
                }
                bool isTopLine() const noexcept
                {
                        return(m_lOffset == 0 && m_iLineNum == 0);
                }
 
                bool isValidPos() const noexcept
                {
                        return(m_iLineNum >= 0); // m_lOffset >= 0
                }
                STREAM_POS_t get_Offset() const noexcept
                {
                        return m_lOffset;
                }
                ITERATE_t get_LineNum() const noexcept          
                {
                        return this->m_iLineNum;
                }
                ITERATE_t get_Line1() const     noexcept        
                {
                        return this->m_iLineNum + 1;
                }
                StrLen_t get_Column1() const noexcept   
                {
                        return this->m_iColNum + 1;
                }
 
                void IncOffset(StrLen_t nLenOffsetSrc) noexcept
                {
                        m_lOffset += nLenOffsetSrc;
                        m_iColNum += nLenOffsetSrc;
                }
                void IncOffset(StrLen_t nLenOffsetSrc, StrLen_t nLenCol) noexcept
                {
                        // nLenCol = 0 = invisible chars don't count.
                        m_lOffset += nLenOffsetSrc;
                        m_iColNum += nLenCol;
                }
                void IncChar(StrLen_t nLenChar = 1) noexcept
                {
                        // Add one single char that is not a newline or tab.
                        m_lOffset += nLenChar;  // UTF8 can span multiple bytes.
                        m_iColNum++;
                }
                void IncLine(StrLen_t nLenChar = 1) noexcept
                {
                        // CRLF or LF
                        m_lOffset += nLenChar;  // UTF8 can span multiple bytes.
                        ++m_iLineNum;
                        m_iColNum = 0;
                }
 
                StrLen_t GetStr2(OUT char* pszOut, StrLen_t nLenOut) const;
        };
 
        class GRAYCORE_LINK cTextReader : public cTextPos
        {
        protected:
                const char* m_pszStart; 
                StrLen_t m_nLenMax;             
 
        public:
                const StrLen_t m_iTabSize;              
 
        public:
                cTextReader(const char* pszStart, StrLen_t nLenMax = StrT::k_LEN_MAX, StrLen_t nTabSize = cStrConst::k_TabSize)
                        : cTextPos(0, 0, 0)
                        , m_pszStart(pszStart)
                        , m_nLenMax(nLenMax)
                        , m_iTabSize(nTabSize)
                {
                }
 
                StrLen_t get_LenMax() const noexcept
                {
                        return m_nLenMax;
                }
                StrLen_t get_LenRemaining() const noexcept
                {
                        if (m_nLenMax < (StrLen_t)m_lOffset)
                                return 0;
                        return m_nLenMax - (StrLen_t)m_lOffset;
                }
                bool isValidIndex() const noexcept
                {
                        return ((UINT)m_lOffset) < (UINT)m_nLenMax; // includes m_lOffset >= 0
                }
                bool isValidPos() const noexcept
                {
                        return m_pszStart != nullptr && isValidIndex(); // includes m_lOffset >= 0
                }
                const char* get_CursorPtr() const noexcept
                {
                        ASSERT(isValidPos());
                        return m_pszStart + this->m_lOffset;
                }
                char get_CursorChar() const noexcept
                {
                        ASSERT(m_pszStart != nullptr);
                        if (!isValidIndex())
                                return '\0';
                        return m_pszStart[this->m_lOffset];
                }
 
                void IncToks(StrLen_t nLen = 1)
                {
                        // Advance the cursor x.
                        // Skip over some known token. It is not a new line. It has no tabs. It is not past the end of the data.
#ifdef _DEBUG
                        ASSERT(isValidPos());
                        char ch = get_CursorChar();
                        ASSERT(!StrChar::IsSpaceX(ch) && ch != '\0');
#endif
                        IncOffset(nLen); // eat chars
                }
                void IncTab(StrLen_t nLenChar = 1)
                {
                        // Skip to next tab stop
                        m_lOffset += nLenChar; // eat tab
                        if (m_iTabSize <= 0)
                                m_iColNum++;
                        else
                                m_iColNum = (m_iColNum / m_iTabSize + 1) * m_iTabSize;
                }
                StrLen_t IncLineCR(StrLen_t nLenChar = 1)
                {
                        // Check for \r\n sequence, and treat this as a single character
                        IncLine(nLenChar);      // bump down to the next line
                        StrLen_t nLen = 1;
                        if (get_CursorChar() == '\n')
                        {
                                m_lOffset += nLenChar; // eat combo char
                                nLen++;
                        }
                        return nLen;
                }
 
                bool isEOF() const
                {
                        return(get_CursorChar() == '\0');
                }
 
                void SetStartPtr(const char* pszStart, StrLen_t nLenMax = StrT::k_LEN_MAX)
                {
                        m_pszStart = pszStart;
                        m_nLenMax = nLenMax;
                        InitTop();
                }
        };
}
 
#endif