Attachment #142151 for bug #189134

View | Details | Raw Unified | Return to bug 189134
Collapse All | Expand All

Lines 48-60 Link Here

(-)../include/CDT.hpp (-141 / +144 lines)
48		48
49	#define C_MAX_SPRINTF_LENGTH 128	49	#define C_MAX_SPRINTF_LENGTH 128
50		50
		51	class CTPP2DECL CDTConstIterator;
		52	class CTPP2DECL CDTIterator;
		53
51	/**	54	/**
52	@class CDT CDT.hpp <CDT.hpp>	55	@class CDT CDT.hpp <CDT.hpp>
53	@brief Common Data Type	56	@brief Common Data Type
54	*/	57	*/
55	class CTPP2DECL CDT	58	class CTPP2DECL CDT
56	{	59	{
57	private:	60	public:
58	/**	61	/**
59	@var typedef STLW::string<CDT> String	62	@var typedef STLW::string<CDT> String
60	@brief internal string definition	63	@brief internal string definition
Lines 72-78 Link Here
72	@brief internal hash definition	75	@brief internal hash definition
73	*/	76	*/
74	typedef STLW::map<String, CDT> Map;	77	typedef STLW::map<String, CDT> Map;
75	public:	78
76	/**	79	/**
77	@enum eValType CDT.hpp <CDT.hpp>	80	@enum eValType CDT.hpp <CDT.hpp>
78	@brief Describes type of stored value	81	@brief Describes type of stored value
Lines 1768-1939 Link Here
1768	virtual ~SortingComparator() throw();	1771	virtual ~SortingComparator() throw();
1769	};	1772	};
1770		1773
1771	// FWD
1772	class CTPP2DECL ConstIterator;
1773
1774	/**
1775	@class Iterator CDT.hpp <CDT.hpp>
1776	@brief CDT[HASH] forward iterator
1777	*/
1778	class CTPP2DECL Iterator
1779	{
1780	private:
1781	friend class CDT;
1782	friend class ConstIterator;
1783
1784	/** Hash iterator */
1785	CDT::Map::iterator itMap;
1786
1787	/**
1788	@brief Constructor
1789	@param itIMap - map iterator
1790	*/
1791	Iterator(CDT::Map::iterator itIMap);
1792	public:
1793	/**
1794	@brief Copy constructor
1795	@param oRhs - object to copy
1796	*/
1797	Iterator(const Iterator & oRhs);
1798
1799	/**
1800	@brief Operator =
1801	@param oRhs - object to copy
1802	*/
1803	Iterator & operator=(const Iterator & oRhs);
1804
1805	/**
1806	@brief Pre-increment operator ++
1807	*/
1808	Iterator & operator++();
1809
1810	/**
1811	@brief Post-increment operator ++
1812	*/
1813	Iterator operator++(int);
1814
1815	/**
1816	@brief Access operator
1817	@return Pair of key => value
1818	*/
1819	STLW::pair<const STLW::string, CDT> * operator->();
1820
1821	/**
1822	@brief Comparison operator
1823	@param oRhs - object to compare
1824	@return true if objects are equal
1825	*/
1826	bool operator ==(const Iterator & oRhs);
1827
1828	/**
1829	@brief Comparison operator
1830	@param oRhs - object to compare
1831	@return true if objects are NOT equal
1832	*/
1833	bool operator !=(const Iterator & oRhs);
1834	};
1835
1836	/**	1774	/**
1837	@brief Get iterator pointed to start of hash	1775	@brief Get iterator pointed to start of hash
1838	*/	1776	*/
1839	Iterator Begin();	1777	CDTIterator Begin();
1840		1778
1841	/**	1779	/**
1842	@brief Get iterator pointed to end of hash	1780	@brief Get iterator pointed to end of hash
1843	*/	1781	*/
1844	Iterator End();	1782	CDTIterator End();
1845		1783
1846	/**	1784	/**
1847	@brief Find element in hash	1785	@brief Find element in hash
1848	@param sKey - element name	1786	@param sKey - element name
1849	@return Iterator pointed to element or to end of hash if nothing found	1787	@return Iterator pointed to element or to end of hash if nothing found
1850	*/	1788	*/
1851	Iterator Find(const STLW::string & sKey);	1789	CDTIterator Find(const STLW::string & sKey);
1852
1853	/**
1854	@class ConstIterator CDT.hpp <CDT.hpp>
1855	@brief CDT[HASH] forward constant iterator
1856	*/
1857	class CTPP2DECL ConstIterator
1858	{
1859	private:
1860	friend class CDT;
1861
1862	/** Hash iterator */
1863	CDT::Map::const_iterator itMap;
1864
1865	public:
1866	/**
1867	@brief Copy constructor
1868	@param oRhs - object to copy
1869	*/
1870	ConstIterator(const ConstIterator & oRhs);
1871
1872	/**
1873	@brief Type cast constructor
1874	@param oRhs - object to copy
1875	*/
1876	ConstIterator(const Iterator & oRhs);
1877
1878	/**
1879	@brief Operator =
1880	@param oRhs - object to copy
1881	*/
1882	ConstIterator & operator=(const ConstIterator & oRhs);
1883
1884	/**
1885	@brief Operator =
1886	@param oRhs - object to copy
1887	*/
1888	ConstIterator & operator=(const Iterator & oRhs);
1889
1890	/**
1891	@brief Pre-increment operator ++
1892	*/
1893	ConstIterator & operator++();
1894
1895	/**
1896	@brief Post-increment operator ++
1897	*/
1898	ConstIterator operator++(int);
1899
1900	/**
1901	@brief Access operator
1902	@return Pair of key => value
1903	*/
1904	const STLW::pair<const STLW::string, CDT> * operator->() const;
1905
1906	/**
1907	@brief Comparison operator
1908	@param oRhs - object to compare
1909	@return true if objects are equal
1910	*/
1911	bool operator ==(const ConstIterator & oRhs) const;
1912
1913	/**
1914	@brief Comparison operator
1915	@param oRhs - object to compare
1916	@return true if objects are NOT equal
1917	*/
1918	bool operator !=(const ConstIterator & oRhs) const;
1919	};
1920		1790
1921	/**	1791	/**
1922	@brief Get constant iterator pointed to start of hash	1792	@brief Get constant iterator pointed to start of hash
1923	*/	1793	*/
1924	ConstIterator Begin() const;	1794	CDTConstIterator Begin() const;
1925		1795
1926	/**	1796	/**
1927	@brief Get constant iterator pointed to end of hash	1797	@brief Get constant iterator pointed to end of hash
1928	*/	1798	*/
1929	ConstIterator End() const;	1799	CDTConstIterator End() const;
1930		1800
1931	/**	1801	/**
1932	@brief Find element in hash	1802	@brief Find element in hash
1933	@param sKey - element name	1803	@param sKey - element name
1934	@return Iterator pointed to element or to end of hash if nothing found	1804	@return Iterator pointed to element or to end of hash if nothing found
1935	*/	1805	*/
1936	ConstIterator Find(const STLW::string & sKey) const;	1806	CDTConstIterator Find(const STLW::string & sKey) const;
1937		1807
1938	/**	1808	/**
1939	@brief Try to cast value to integer or to IEEE floating point value	1809	@brief Try to cast value to integer or to IEEE floating point value
Lines 2009-2014 Link Here
2009		1879
2010	};	1880	};
2011		1881
		1882
		1883	/**
		1884	@class CDTIterator CDT.hpp <CDT.hpp>
		1885	@brief CDT[HASH] forward iterator
		1886	*/
		1887	class CTPP2DECL CDTIterator
		1888	{
		1889	private:
		1890	friend class CDT;
		1891	friend class CDTConstIterator;
		1892
		1893	/** Hash iterator */
		1894	CDT::Map::iterator itMap;
		1895
		1896	/**
		1897	@brief Constructor
		1898	@param itIMap - map iterator
		1899	*/
		1900	CDTIterator(CDT::Map::iterator itIMap);
		1901	public:
		1902	/**
		1903	@brief Copy constructor
		1904	@param oRhs - object to copy
		1905	*/
		1906	CDTIterator(const CDTIterator & oRhs);
		1907
		1908	/**
		1909	@brief Operator =
		1910	@param oRhs - object to copy
		1911	*/
		1912	CDTIterator & operator=(const CDTIterator & oRhs);
		1913
		1914	/**
		1915	@brief Pre-increment operator ++
		1916	*/
		1917	CDTIterator & operator++();
		1918
		1919	/**
		1920	@brief Post-increment operator ++
		1921	*/
		1922	CDTIterator operator++(int);
		1923
		1924	/**
		1925	@brief Access operator
		1926	@return Pair of key => value
		1927	*/
		1928	STLW::pair<const STLW::string, CDT> * operator->();
		1929
		1930	/**
		1931	@brief Comparison operator
		1932	@param oRhs - object to compare
		1933	@return true if objects are equal
		1934	*/
		1935	bool operator ==(const CDTIterator & oRhs);
		1936
		1937	/**
		1938	@brief Comparison operator
		1939	@param oRhs - object to compare
		1940	@return true if objects are NOT equal
		1941	*/
		1942	bool operator !=(const CDTIterator & oRhs);
		1943	};
		1944
		1945
1946	/**
1947	@class CDTConstIterator CDT.hpp <CDT.hpp>
1948	@brief CDT[HASH] forward constant iterator
1949	*/
1950	class CTPP2DECL CDTConstIterator
1951	{
1952	private:
1953	friend class CDT;
1954
1955	/** Hash iterator */
1956	CDT::Map::const_iterator itMap;
1957
1958	public:
1959	/**
1960	@brief Copy constructor
1961	@param oRhs - object to copy
1962	*/
1963	CDTConstIterator(const CDTConstIterator & oRhs);
1964
1965	/**
1966	@brief Type cast constructor
1967	@param oRhs - object to copy
1968	*/
1969	CDTConstIterator(const CDTIterator & oRhs);
1970
1971	/**
1972	@brief Operator =
1973	@param oRhs - object to copy
1974	*/
1975	CDTConstIterator & operator=(const CDTConstIterator & oRhs);
1976
1977	/**
1978	@brief Operator =
1979	@param oRhs - object to copy
1980	*/
1981	CDTConstIterator & operator=(const CDTIterator & oRhs);
1982
1983	/**
1984	@brief Pre-increment operator ++
1985	*/
1986	CDTConstIterator & operator++();
1987
1988	/**
1989	@brief Post-increment operator ++
1990	*/
1991	CDTConstIterator operator++(int);
1992
1993	/**
1994	@brief Access operator
1995	@return Pair of key => value
1996	*/
1997	const STLW::pair<const STLW::string, CDT> * operator->() const;
1998
1999	/**
2000	@brief Comparison operator
2001	@param oRhs - object to compare
2002	@return true if objects are equal
2003	*/
2004	bool operator ==(const CDTConstIterator & oRhs) const;
2005
2006	/**
2007	@brief Comparison operator
2008	@param oRhs - object to compare
2009	@return true if objects are NOT equal
2010	*/
2011	bool operator !=(const CDTConstIterator & oRhs) const;
2012	};
2013
2014
2012	// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	2015	// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2013	//	2016	//
2014	// Realization	2017	// Realization




//
// Constructor
//
CDTIterator::CDTIterator(CDT::Map::iterator itIMap): itMap(itIMap) { ;; }

//
// Copy constructor
//
CDTIterator::CDTIterator(const CDTIterator & oRhs): itMap(oRhs.itMap) { ;; }

//
// Operator =
//
CDTIterator & CDTIterator::operator=(const CDTIterator & oRhs)
{
	if (this != &oRhs) { itMap = oRhs.itMap; }


//
// Pre-increment operator ++
//
CDTIterator & CDTIterator::operator++()
{
	++itMap;


//
// Post-increment operator ++
//
CDTIterator CDTIterator::operator++(int)
{
	CDTIterator oTMP = *this;

	++itMap;


//
// Access operator
//
STLW::pair<const STLW::string, CDT> * CDTIterator::operator->() { return &(*itMap); }

//
// Comparison operator
//
bool CDTIterator::operator ==(const CDTIterator & oRhs) { return (itMap == oRhs.itMap); }

//
// Comparison operator
//
bool CDTIterator::operator !=(const CDTIterator & oRhs) { return (itMap != oRhs.itMap); }

//
// Get iterator pointed to start of hash
//
CDTIterator CDT::Begin()
{
	if (eValueType != HASH_VAL) { throw CDTAccessException(); }

return CDTIterator(u.p_data -> u.m_data -> begin());
}

//
// Get iterator pointed to end of hash
//
CDTIterator CDT::End()
{
	if (eValueType != HASH_VAL) { throw CDTAccessException(); }

	return CDTIterator(u.p_data -> u.m_data -> end());
}

//
// Find element in hash
//
CDTIterator CDT::Find(const STLW::string & sKey)
{
	if (eValueType != HASH_VAL) { throw CDTAccessException(); }

return CDTIterator(u.p_data -> u.m_data -> find(sKey));
}

// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//
// Copy constructor
//
CDTConstIterator::CDTConstIterator(const CDTConstIterator & oRhs): itMap(oRhs.itMap) { ;; }

//
// Type cast constructor
//
CDTConstIterator::CDTConstIterator(const CDTIterator & oRhs): itMap(oRhs.itMap) { ;; }

//
// Operator =
//
CDTConstIterator & CDTConstIterator::operator=(const CDTConstIterator & oRhs)
{
	if (this != &oRhs) { itMap = oRhs.itMap; }


//
// Operator =
//
CDTConstIterator & CDTConstIterator::operator=(const CDTIterator & oRhs)
{
	itMap = oRhs.itMap;


//
// Pre-increment operator ++
//
CDTConstIterator & CDTConstIterator::operator++()
{
	++itMap;


//
// Post-increment operator ++
//
CDTConstIterator CDTConstIterator::operator++(int)
{
	CDTConstIterator oTMP = *this;

	++itMap;


//
// Access operator
//
const STLW::pair<const STLW::string, CDT> * CDTConstIterator::operator->() const { return &(*itMap); }

//
// Comparison operator
//
bool CDTConstIterator::operator ==(const CDTConstIterator & oRhs) const { return (itMap == oRhs.itMap); }

//
// Comparison operator
//
bool CDTConstIterator::operator !=(const CDTConstIterator & oRhs) const { return (itMap != oRhs.itMap); }

//
// Get constant iterator pointed to start of hash
//
CDTConstIterator CDT::Begin() const
{
	if (eValueType != HASH_VAL) { throw CDTAccessException(); }

return CDTConstIterator(u.p_data -> u.m_data -> begin());
}

//
// Get constant iterator pointed to end of hash
//
CDTConstIterator CDT::End() const
{
	if (eValueType != HASH_VAL) { throw CDTAccessException(); }

return CDTConstIterator(u.p_data -> u.m_data -> end());
}

//
// Find element in hash
//
CDTConstIterator CDT::Find(const STLW::string & sKey) const
{
	if (eValueType != HASH_VAL) { throw CDTAccessException(); }

return CDTConstIterator(u.p_data -> u.m_data -> find(sKey));
}

// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


		case HASH_VAL:
			{
				CDTConstIterator itHash = oData.Begin();
				if (itHash == oData.End())
				{
					if (!bGlobalScope) { sResult += "{ }"; }

Lines 38-43 Link Here

(-)../src/CTPP2FileSourceLoader.cpp (+1 lines)
38	#include <errno.h>	38	#include <errno.h>
39	#include <stdio.h>	39	#include <stdio.h>
40	#include <stdlib.h>	40	#include <stdlib.h>
		41	#include <unistd.h>
41		42
42	#ifdef WIN32	43	#ifdef WIN32
43	#include <direct.h> /* getcwd */	44	#include <direct.h> /* getcwd */

Lines 751-757 Link Here

(-)../src/CTPP2Util.cpp (-1 / +1 lines)
751	case CDT::HASH_VAL:	751	case CDT::HASH_VAL:
752	{	752	{
753	oResult.Write("{", 1);	753	oResult.Write("{", 1);
754	CDT::ConstIterator itCDTCArray = oCDT.Begin();	754	CDTConstIterator itCDTCArray = oCDT.Begin();
755	while (itCDTCArray != oCDT.End())	755	while (itCDTCArray != oCDT.End())
756	{	756	{
757	oResult.Write("\"", 1);	757	oResult.Write("\"", 1);

Lines 1440-1446 Link Here

(-)../src/CTPP2VM.cpp (-1 / +1 lines)
1440		1440
1441	if (oRegs[iSrcReg].GetType() == CDT::HASH_VAL)	1441	if (oRegs[iSrcReg].GetType() == CDT::HASH_VAL)
1442	{	1442	{
1443	CDT::Iterator it = oRegs[iSrcReg].Begin();	1443	CDTIterator it = oRegs[iSrcReg].Begin();
1444	for (INT_32 iI = 0; iI < iIdx; ++iI) { ++it; }	1444	for (INT_32 iI = 0; iI < iIdx; ++iI) { ++it; }
1445	#ifdef _DEBUG	1445	#ifdef _DEBUG
1446	fprintf(stderr, "(`%s`): %s\n", it->first.c_str(), it->second.GetString().c_str());	1446	fprintf(stderr, "(`%s`): %s\n", it->first.c_str(), it->second.GetString().c_str());

Lines 590-596 Link Here

(-)../tests/CDTTest.cpp (-2 / +2 lines)
590		590
591	fprintf(stderr, "Get HASH values: %s\n", oCDT_array.GetHashValues().Dump().c_str());	591	fprintf(stderr, "Get HASH values: %s\n", oCDT_array.GetHashValues().Dump().c_str());
592		592
593	CDT::Iterator itCDTArray = oCDT_array.Begin();	593	CDTIterator itCDTArray = oCDT_array.Begin();
594	while (itCDTArray != oCDT_array.End())	594	while (itCDTArray != oCDT_array.End())
595	{	595	{
596	fprintf(stderr, "oCDT_array[\"%s\"] => %s\n", itCDTArray -> first.c_str(), itCDTArray -> second.GetString().c_str());	596	fprintf(stderr, "oCDT_array[\"%s\"] => %s\n", itCDTArray -> first.c_str(), itCDTArray -> second.GetString().c_str());
Lines 598-604 Link Here
598	++itCDTArray;	598	++itCDTArray;
599	}	599	}
600		600
601	CDT::ConstIterator itCDTCArray = oCDT_array.Begin();	601	CDTConstIterator itCDTCArray = oCDT_array.Begin();
602	while (itCDTCArray != oCDT_array.End())	602	while (itCDTCArray != oCDT_array.End())
603	{	603	{
604	fprintf(stderr, "oCDT_array[\"%s\"] => %s\n", itCDTCArray -> first.c_str(), itCDTCArray -> second.GetString().c_str());	604	fprintf(stderr, "oCDT_array[\"%s\"] => %s\n", itCDTCArray -> first.c_str(), itCDTCArray -> second.GetString().c_str());

Return to bug 189134

Lines 108-124 Link Here

(-)../src/CDT.cpp (-32 / +32 lines)
108	//	108	//
109	// Constructor	109	// Constructor
110	//	110	//
111	CDT::Iterator::Iterator(CDT::Map::iterator itIMap): itMap(itIMap) { ;; }	111	CDTIterator::CDTIterator(CDT::Map::iterator itIMap): itMap(itIMap) { ;; }
112		112
113	//	113	//
114	// Copy constructor	114	// Copy constructor
115	//	115	//
116	CDT::Iterator::Iterator(const CDT::Iterator & oRhs): itMap(oRhs.itMap) { ;; }	116	CDTIterator::CDTIterator(const CDTIterator & oRhs): itMap(oRhs.itMap) { ;; }
117		117
118	//	118	//
119	// Operator =	119	// Operator =
120	//	120	//
121	CDT::Iterator & CDT::Iterator::operator=(const CDT::Iterator & oRhs)	121	CDTIterator & CDTIterator::operator=(const CDTIterator & oRhs)
122	{	122	{
123	if (this != &oRhs) { itMap = oRhs.itMap; }	123	if (this != &oRhs) { itMap = oRhs.itMap; }
124		124
Lines 128-134 Link Here
128	//	128	//
129	// Pre-increment operator ++	129	// Pre-increment operator ++
130	//	130	//
131	CDT::Iterator & CDT::Iterator::operator++()	131	CDTIterator & CDTIterator::operator++()
132	{	132	{
133	++itMap;	133	++itMap;
134		134
Lines 138-146 Link Here
138	//	138	//
139	// Post-increment operator ++	139	// Post-increment operator ++
140	//	140	//
141	CDT::Iterator CDT::Iterator::operator++(int)	141	CDTIterator CDTIterator::operator++(int)
142	{	142	{
143	Iterator oTMP = *this;	143	CDTIterator oTMP = *this;
144		144
145	++itMap;	145	++itMap;
146		146
Lines 150-195 Link Here
150	//	150	//
151	// Access operator	151	// Access operator
152	//	152	//
153	STLW::pair<const STLW::string, CDT> * CDT::Iterator::operator->() { return &(*itMap); }	153	STLW::pair<const STLW::string, CDT> * CDTIterator::operator->() { return &(*itMap); }
154		154
155	//	155	//
156	// Comparison operator	156	// Comparison operator
157	//	157	//
158	bool CDT::Iterator::operator ==(const CDT::Iterator & oRhs) { return (itMap == oRhs.itMap); }	158	bool CDTIterator::operator ==(const CDTIterator & oRhs) { return (itMap == oRhs.itMap); }
159		159
160	//	160	//
161	// Comparison operator	161	// Comparison operator
162	//	162	//
163	bool CDT::Iterator::operator !=(const CDT::Iterator & oRhs) { return (itMap != oRhs.itMap); }	163	bool CDTIterator::operator !=(const CDTIterator & oRhs) { return (itMap != oRhs.itMap); }
164		164
165	//	165	//
166	// Get iterator pointed to start of hash	166	// Get iterator pointed to start of hash
167	//	167	//
168	CDT::Iterator CDT::Begin()	168	CDTIterator CDT::Begin()
169	{	169	{
170	if (eValueType != HASH_VAL) { throw CDTAccessException(); }	170	if (eValueType != HASH_VAL) { throw CDTAccessException(); }
171		171
172	return Iterator(u.p_data -> u.m_data -> begin());	172	return CDTIterator(u.p_data -> u.m_data -> begin());
173	}	173	}
174		174
175	//	175	//
176	// Get iterator pointed to end of hash	176	// Get iterator pointed to end of hash
177	//	177	//
178	CDT::Iterator CDT::End()	178	CDTIterator CDT::End()
179	{	179	{
180	if (eValueType != HASH_VAL) { throw CDTAccessException(); }	180	if (eValueType != HASH_VAL) { throw CDTAccessException(); }
181		181
182	return Iterator(u.p_data -> u.m_data -> end());	182	return CDTIterator(u.p_data -> u.m_data -> end());
183	}	183	}
184		184
185	//	185	//
186	// Find element in hash	186	// Find element in hash
187	//	187	//
188	CDT::Iterator CDT::Find(const STLW::string & sKey)	188	CDTIterator CDT::Find(const STLW::string & sKey)
189	{	189	{
190	if (eValueType != HASH_VAL) { throw CDTAccessException(); }	190	if (eValueType != HASH_VAL) { throw CDTAccessException(); }
191		191
192	return Iterator(u.p_data -> u.m_data -> find(sKey));	192	return CDTIterator(u.p_data -> u.m_data -> find(sKey));
193	}	193	}
194		194
195	// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	195	// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Lines 200-216 Link Here
200	//	200	//
201	// Copy constructor	201	// Copy constructor
202	//	202	//
203	CDT::ConstIterator::ConstIterator(const CDT::ConstIterator & oRhs): itMap(oRhs.itMap) { ;; }	203	CDTConstIterator::CDTConstIterator(const CDTConstIterator & oRhs): itMap(oRhs.itMap) { ;; }
204		204
205	//	205	//
206	// Type cast constructor	206	// Type cast constructor
207	//	207	//
208	CDT::ConstIterator::ConstIterator(const CDT::Iterator & oRhs): itMap(oRhs.itMap) { ;; }	208	CDTConstIterator::CDTConstIterator(const CDTIterator & oRhs): itMap(oRhs.itMap) { ;; }
209		209
210	//	210	//
211	// Operator =	211	// Operator =
212	//	212	//
213	CDT::ConstIterator & CDT::ConstIterator::operator=(const ConstIterator & oRhs)	213	CDTConstIterator & CDTConstIterator::operator=(const CDTConstIterator & oRhs)
214	{	214	{
215	if (this != &oRhs) { itMap = oRhs.itMap; }	215	if (this != &oRhs) { itMap = oRhs.itMap; }
216		216
Lines 220-226 Link Here
220	//	220	//
221	// Operator =	221	// Operator =
222	//	222	//
223	CDT::ConstIterator & CDT::ConstIterator::operator=(const CDT::Iterator & oRhs)	223	CDTConstIterator & CDTConstIterator::operator=(const CDTIterator & oRhs)
224	{	224	{
225	itMap = oRhs.itMap;	225	itMap = oRhs.itMap;
226		226
Lines 230-236 Link Here
230	//	230	//
231	// Pre-increment operator ++	231	// Pre-increment operator ++
232	//	232	//
233	CDT::ConstIterator & CDT::ConstIterator::operator++()	233	CDTConstIterator & CDTConstIterator::operator++()
234	{	234	{
235	++itMap;	235	++itMap;
236		236
Lines 240-248 Link Here
240	//	240	//
241	// Post-increment operator ++	241	// Post-increment operator ++
242	//	242	//
243	CDT::ConstIterator CDT::ConstIterator::operator++(int)	243	CDTConstIterator CDTConstIterator::operator++(int)
244	{	244	{
245	ConstIterator oTMP = *this;	245	CDTConstIterator oTMP = *this;
246		246
247	++itMap;	247	++itMap;
248		248
Lines 252-297 Link Here
252	//	252	//
253	// Access operator	253	// Access operator
254	//	254	//
255	const STLW::pair<const STLW::string, CDT> * CDT::ConstIterator::operator->() const { return &(*itMap); }	255	const STLW::pair<const STLW::string, CDT> * CDTConstIterator::operator->() const { return &(*itMap); }
256		256
257	//	257	//
258	// Comparison operator	258	// Comparison operator
259	//	259	//
260	bool CDT::ConstIterator::operator ==(const CDT::ConstIterator & oRhs) const { return (itMap == oRhs.itMap); }	260	bool CDTConstIterator::operator ==(const CDTConstIterator & oRhs) const { return (itMap == oRhs.itMap); }
261		261
262	//	262	//
263	// Comparison operator	263	// Comparison operator
264	//	264	//
265	bool CDT::ConstIterator::operator !=(const CDT::ConstIterator & oRhs) const { return (itMap != oRhs.itMap); }	265	bool CDTConstIterator::operator !=(const CDTConstIterator & oRhs) const { return (itMap != oRhs.itMap); }
266		266
267	//	267	//
268	// Get constant iterator pointed to start of hash	268	// Get constant iterator pointed to start of hash
269	//	269	//
270	CDT::ConstIterator CDT::Begin() const	270	CDTConstIterator CDT::Begin() const
271	{	271	{
272	if (eValueType != HASH_VAL) { throw CDTAccessException(); }	272	if (eValueType != HASH_VAL) { throw CDTAccessException(); }
273		273
274	return ConstIterator(u.p_data -> u.m_data -> begin());	274	return CDTConstIterator(u.p_data -> u.m_data -> begin());
275	}	275	}
276		276
277	//	277	//
278	// Get constant iterator pointed to end of hash	278	// Get constant iterator pointed to end of hash
279	//	279	//
280	CDT::ConstIterator CDT::End() const	280	CDTConstIterator CDT::End() const
281	{	281	{
282	if (eValueType != HASH_VAL) { throw CDTAccessException(); }	282	if (eValueType != HASH_VAL) { throw CDTAccessException(); }
283		283
284	return ConstIterator(u.p_data -> u.m_data -> end());	284	return CDTConstIterator(u.p_data -> u.m_data -> end());
285	}	285	}
286		286
287	//	287	//
288	// Find element in hash	288	// Find element in hash
289	//	289	//
290	CDT::ConstIterator CDT::Find(const STLW::string & sKey) const	290	CDTConstIterator CDT::Find(const STLW::string & sKey) const
291	{	291	{
292	if (eValueType != HASH_VAL) { throw CDTAccessException(); }	292	if (eValueType != HASH_VAL) { throw CDTAccessException(); }
293		293
294	return ConstIterator(u.p_data -> u.m_data -> find(sKey));	294	return CDTConstIterator(u.p_data -> u.m_data -> find(sKey));
295	}	295	}
296		296
297	// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	297	// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Lines 4138-4144 Link Here
4138		4138
4139	case HASH_VAL:	4139	case HASH_VAL:
4140	{	4140	{
4141	ConstIterator itHash = oData.Begin();	4141	CDTConstIterator itHash = oData.Begin();
4142	if (itHash == oData.End())	4142	if (itHash == oData.End())
4143	{	4143	{
4144	if (!bGlobalScope) { sResult += "{ }"; }	4144	if (!bGlobalScope) { sResult += "{ }"; }