cIniSection.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cIniSection_H
#define _INC_cIniSection_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cIniBase.h"
#include "StrArg.h"
#include "cHeap.h"
#include "cTextPos.h"
 
namespace Gray
{
#define INI_CR "\r\n"   
 
        class cStreamOutput;
 
        class GRAYCORE_LINK cIniWriter
        {
 
        protected:
                cStreamOutput* m_pOut;  
                bool m_bStartedSection; 
 
        public:
                cIniWriter(cStreamOutput* pOut)
                        : m_pOut(pOut)
                        , m_bStartedSection(false)
                {
                        ASSERT(pOut != nullptr);
                }
 
                HRESULT WriteSectionHead0(const IniChar_t* pszSectionData);
                HRESULT WriteSectionHead1(const IniChar_t* pszSectionType, const IniChar_t* pszSectionName);
                HRESULT WriteSectionHead1Q(const IniChar_t* pszSection, const IniChar_t* pszArg);
                HRESULT _cdecl WriteSectionHeadFormat(const IniChar_t* pszSectionType, const IniChar_t* pszArgFormat, ...);
 
                HRESULT WriteKeyUnk(const IniChar_t* pszKey, const IniChar_t* pszData);
                HRESULT WriteKeyStrQ(const IniChar_t* pszKey, const IniChar_t* pszVal);
                HRESULT WriteKeyInt(const IniChar_t* pszKey, int nVal);
                HRESULT WriteKeyUInt(const IniChar_t* pszKey, UINT nVal);
        };
 
        struct GRAYCORE_LINK cIniReader // static
        {
 
                static bool GRAYCALL IsSectionHeader(const IniChar_t* pszLine);
 
                static bool GRAYCALL IsLineComment(const IniChar_t* pszLine);
                static IniChar_t* GRAYCALL FindLineArg(const IniChar_t* pszLine, bool bAllowSpace = false);
                static StrLen_t GRAYCALL FindScriptLineEnd(const IniChar_t* pLineStr);
                static cStringI GRAYCALL GetLineParse2(const IniChar_t* pszLine, IniChar_t** ppszArgs = nullptr);
                static cStringI GRAYCALL GetLineParse3(const IniChar_t* pszLine, OUT cStringI& rsArgs);
        };
 
        class GRAYCORE_LINK cIniSectionData
                : public IIniBaseEnumerator
                , public IIniBaseGetter
                , public IIniBaseSetter
                , public cIniReader
        {
 
                friend class cIniFile;
        public:
                static const StrLen_t k_SECTION_SIZE_MAX = (256 * 1024); 
                static const ITERATE_t k_LINE_QTY_MAX = (8 * 1024);     
                static const StrLen_t k_LINE_LEN_MAX = (4 * 1024);      
                static const StrLen_t k_LINE_LEN_DEF = (1024);          
 
        protected:
                bool m_bStripComments;  
 
        private:
                cHeapBlock m_Buffer;            
                StrLen_t m_iBufferUsed;         
 
                IniChar_t** m_ppLines;          
                ITERATE_t m_iLinesAlloc;        
                ITERATE_t m_iLinesUsed;         
 
        private:
                void MoveLineOffsets(ITERATE_t iLineStart, INT_PTR iDiffChars);
 
        protected:
                IniChar_t* AllocBuffer(StrLen_t nSizeChars);
                void AllocLines(ITERATE_t iLinesAlloc);
 
                IniChar_t* AllocBeginMin(StrLen_t nSizeChars);
 
        public:
                cIniSectionData(bool bStripComments = false) noexcept;
                virtual ~cIniSectionData();
                void DisposeThis();
 
                bool isStripped() const noexcept
                {
                        return m_bStripComments;
                }
 
                StrLen_t get_BufferUsed() const noexcept
                {
                        if (m_iLinesUsed <= 0)
                                return 0;
                        return m_iBufferUsed;
                }
                StrLen_t get_BufferSize() const noexcept
                {
                        if (m_iLinesUsed <= 0)
                                return 0;
                        return (StrLen_t)m_Buffer.get_DataSize();
                }
 
                ITERATE_t get_LineQty() const noexcept
                {
                        return m_iLinesUsed;
                }
                IniChar_t* GetLineEnum(ITERATE_t iLine = 0) const noexcept
                {
                        if (IS_INDEX_BAD(iLine, m_iLinesUsed))
                                return nullptr;
                        return m_ppLines[iLine];
                }
 
                static StrLen_t GRAYCALL IsLineTrigger(const IniChar_t* pszLine);
                ITERATE_t FindTriggerName(const IniChar_t* pszTrigName) const;
 
                virtual HRESULT PropEnum(IPROPIDX_t ePropIdx, OUT cStringI& rsValue, cStringI* psKey = nullptr) const override;
                void ClearLineQty();
 
                ITERATE_t FindKeyLine(const IniChar_t* pszKeyName, bool bPrefixOnly = false) const; 
                const IniChar_t* FindKeyLinePtr(const IniChar_t* pszKey) const;
                const IniChar_t* FindArgForKey(const IniChar_t* pszKey, const IniChar_t* pszDefault = nullptr) const;
                int FindIntForKey(const IniChar_t* pszKey, int iDefault = 0) const;
 
                virtual HRESULT PropGet(const IniChar_t* pszPropTag, OUT cStringI& rsValue) const override;
 
                bool IsValidLines() const;
                void SetLinesCopy(const cIniSectionData& section);      // Dupe another section.
                ITERATE_t AddLine(const IniChar_t* pszLine);
                bool SetLine(ITERATE_t iLine, const IniChar_t* pszLine = nullptr);
                bool RemoveLine(ITERATE_t iLine)
                {
                        return SetLine(iLine, nullptr);
                }
 
                static StrLen_t GRAYCALL MakeLine(IniChar_t* pszTmp, StrLen_t iSizeMax, const IniChar_t* pszKey, const IniChar_t* pszArg, IniChar_t chSep = '=');
 
                ITERATE_t AddKeyArg(const IniChar_t* pszKey, const IniChar_t* pszArg);
                ITERATE_t AddKeyInt(const IniChar_t* pszKey, int iArg)
                {
                        return AddKeyArg(pszKey, StrArg<IniChar_t>(iArg));
                }
                ITERATE_t SetKeyArg(const IniChar_t* pszKey, const IniChar_t* pszArg);
                ITERATE_t SetKeyInt(const IniChar_t* pszKey, int iArg)
                {
                        return SetKeyArg(pszKey, StrArg<IniChar_t>(iArg));
                }
                void AllocComplete();
                virtual HRESULT PropSet(const IniChar_t* pszPropTag, const IniChar_t* pszValue) override;
 
                StrLen_t SetLinesParse(const IniChar_t* pszData, StrLen_t iLen = k_StrLen_UNK, const IniChar_t* pszSep = nullptr, STRP_MASK_t uFlags = (STRP_START_WHITE | STRP_MERGE_CRNL | STRP_END_WHITE | STRP_EMPTY_STOP));
                cStringA GetStringAll(const IniChar_t* pszSep = nullptr) const;
 
                HRESULT ReadSectionData(cStringA& rsSectionNext, cStreamInput& stream, bool bStripComments);
                HRESULT WriteSectionData(cStreamOutput& file);
        };
 
        class GRAYCORE_LINK cIniSection : public cIniSectionData
        {
                typedef cIniSectionData SUPER_t;
 
        protected:
                cStringI m_sSectionTitle;       
 
        public:
                cIniSection(bool bStripComments = false) noexcept
                        : cIniSectionData(bStripComments)
                {
                }
                cIniSection(cStringI sSectionTitle, bool bStripComments = false)
                        : cIniSectionData(bStripComments)
                        , m_sSectionTitle(sSectionTitle)
                {
                }
                cIniSection(const cIniSection& rSectionCopy);
 
                const cStringI& get_SectionTitle() const noexcept
                {
                        return m_sSectionTitle;
                }
                cString get_Name() const noexcept
                {
                        return cString(get_SectionTitle());
                }
 
                static cStringI GRAYCALL GetSectionTitleParse(cStringI sSectionTitle, cStringI* psPropTag);
 
                static bool GRAYCALL IsSectionTypeRoot(const IniChar_t* pszSection) noexcept
                {
                        return StrT::IsNullOrEmpty(pszSection);
                }
                static bool GRAYCALL IsSectionTypeMatch(const IniChar_t* pszSection1, const IniChar_t* pszSection2) noexcept;
 
                HRESULT WriteSection(cStreamOutput& file);
 
                bool IsSectionType(const IniChar_t* pszSectionType) const noexcept
                {
                        return IsSectionTypeMatch(m_sSectionTitle, pszSectionType);
                }
                UNITTEST_FRIEND(cIniSection);
        };
 
        class GRAYCORE_LINK cIniSectionEntry : public cRefBase, public cIniSection
        {
 
        public:
                cTextPos m_FilePos;     
 
        public:
                cIniSectionEntry(cStringI sSectionTitle, bool bStripComments = false, int iLine = 0)
                        : cIniSection(sSectionTitle, bStripComments)
                        , m_FilePos(0, iLine)
                {
                }
                cIniSectionEntry(const cIniSectionEntry& rSectionCopy)
                        : cIniSection(rSectionCopy)
                        , m_FilePos(rSectionCopy.m_FilePos)
                {
                }
                virtual ~cIniSectionEntry()
                {
                }
 
                int get_HashCode() const noexcept
                {
                        return (int)m_FilePos.get_Line1();
                }
        };
        typedef cRefPtr<cIniSectionEntry> cIniSectionEntryPtr;
};
 
#endif