Attachment 142151 Details for Bug 189134 – file.diff

[patch] file.diff

file.diff (text/plain), 15.47 KB, created by Shambler on 2014-04-30 11:40:00 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Shambler

Created: 2014-04-30 11:40:00 UTC

Size: 15.47 KB

patch

obsolete

>--- ../../ctpp2.orig/include/CDT.hpp	2012-11-11 01:45:43.000000000 +0400
>+++ ../include/CDT.hpp	2014-04-30 14:08:29.000000000 +0400
>@@ -48,13 +48,16 @@
> 
> #define C_MAX_SPRINTF_LENGTH 128
> 
>+class CTPP2DECL CDTConstIterator;
>+class CTPP2DECL CDTIterator;
>+
> /**
>   @class CDT CDT.hpp <CDT.hpp>
>   @brief Common Data Type
> */
> class CTPP2DECL CDT
> {
>-private:
>+public:
> 	/**
> 	  @var typedef STLW::string<CDT> String
> 	  @brief internal string definition
>@@ -72,7 +75,7 @@
> 	  @brief internal hash definition
> 	*/
> 	typedef STLW::map<String, CDT>  Map;
>-public:
>+
> 	/**
> 	  @enum eValType CDT.hpp <CDT.hpp>
> 	  @brief Describes type of stored value
>@@ -1768,172 +1771,39 @@
> 		virtual ~SortingComparator() throw();
> 	};
> 
>-	// FWD
>-	class CTPP2DECL ConstIterator;
>-
>-	/**
>-	  @class Iterator CDT.hpp <CDT.hpp>
>-	  @brief CDT[HASH] forward iterator
>-	*/
>-	class CTPP2DECL Iterator
>-	{
>-	private:
>-		friend class CDT;
>-		friend class ConstIterator;
>-
>-		/** Hash iterator */
>-		CDT::Map::iterator itMap;
>-
>-		/**
>-		  @brief Constructor
>-		  @param itIMap - map iterator
>-		*/
>-		Iterator(CDT::Map::iterator itIMap);
>-	public:
>-		/**
>-		  @brief Copy constructor
>-		  @param oRhs - object to copy
>-		*/
>-		Iterator(const Iterator & oRhs);
>-
>-		/**
>-		  @brief Operator =
>-		  @param oRhs - object to copy
>-		*/
>-		Iterator & operator=(const Iterator & oRhs);
>-
>-		/**
>-		  @brief Pre-increment operator ++
>-		*/
>-		Iterator & operator++();
>-
>-		/**
>-		  @brief Post-increment operator ++
>-		*/
>-		Iterator operator++(int);
>-
>-		/**
>-		  @brief Access operator
>-		  @return Pair of key => value
>-		*/
>-		STLW::pair<const STLW::string, CDT> * operator->();
>-
>-		/**
>-		  @brief Comparison operator
>-		  @param oRhs - object to compare
>-		  @return true if objects are equal
>-		*/
>-		bool operator ==(const Iterator & oRhs);
>-
>-		/**
>-		  @brief Comparison operator
>-		  @param oRhs - object to compare
>-		  @return true if objects are NOT equal
>-		*/
>-		bool operator !=(const Iterator & oRhs);
>-	};
>-
> 	/**
> 	  @brief Get iterator pointed to start of hash
> 	*/
>-	Iterator Begin();
>+	CDTIterator Begin();
> 
> 	/**
> 	  @brief Get iterator pointed to end of hash
> 	*/
>-	Iterator End();
>+	CDTIterator End();
> 
> 	/**
> 	  @brief Find element in hash
> 	  @param sKey - element name
> 	  @return Iterator pointed to element or to end of hash if nothing found
> 	*/
>-	Iterator Find(const STLW::string & sKey);
>-
>-	/**
>-	  @class ConstIterator CDT.hpp <CDT.hpp>
>-	  @brief CDT[HASH] forward constant iterator
>-	*/
>-	class CTPP2DECL ConstIterator
>-	{
>-	private:
>-		friend class CDT;
>-
>-		/** Hash iterator */
>-		CDT::Map::const_iterator itMap;
>-
>-	public:
>-		/**
>-		  @brief Copy constructor
>-		  @param oRhs - object to copy
>-		*/
>-		ConstIterator(const ConstIterator & oRhs);
>-
>-		/**
>-		  @brief Type cast constructor
>-		  @param oRhs - object to copy
>-		*/
>-		ConstIterator(const Iterator & oRhs);
>-
>-		/**
>-		  @brief Operator =
>-		  @param oRhs - object to copy
>-		*/
>-		ConstIterator & operator=(const ConstIterator & oRhs);
>-
>-		/**
>-		  @brief Operator =
>-		  @param oRhs - object to copy
>-		*/
>-		ConstIterator & operator=(const Iterator & oRhs);
>-
>-		/**
>-		  @brief Pre-increment operator ++
>-		*/
>-		ConstIterator & operator++();
>-
>-		/**
>-		  @brief Post-increment operator ++
>-		*/
>-		ConstIterator operator++(int);
>-
>-		/**
>-		  @brief Access operator
>-		  @return Pair of key => value
>-		*/
>-		const STLW::pair<const STLW::string, CDT> * operator->() const;
>-
>-		/**
>-		  @brief Comparison operator
>-		  @param oRhs - object to compare
>-		  @return true if objects are equal
>-		*/
>-		bool operator ==(const ConstIterator & oRhs) const;
>-
>-		/**
>-		  @brief Comparison operator
>-		  @param oRhs - object to compare
>-		  @return true if objects are NOT equal
>-		*/
>-		bool operator !=(const ConstIterator & oRhs) const;
>-	};
>+	CDTIterator Find(const STLW::string & sKey);
> 
> 	/**
> 	  @brief Get constant iterator pointed to start of hash
> 	*/
>-	ConstIterator Begin() const;
>+	CDTConstIterator Begin() const;
> 
> 	/**
> 	  @brief Get constant iterator pointed to end of hash
> 	*/
>-	ConstIterator End() const;
>+	CDTConstIterator End() const;
> 
> 	/**
> 	  @brief Find element in hash
> 	  @param sKey - element name
> 	  @return Iterator pointed to element or to end of hash if nothing found
> 	*/
>-	ConstIterator Find(const STLW::string & sKey) const;
>+	CDTConstIterator Find(const STLW::string & sKey) const;
> 
> 	/**
> 	  @brief Try to cast value to integer or to IEEE floating point value
>@@ -2009,6 +1879,139 @@
> 
> };
> 
>+
>+/**
>+  @class CDTIterator CDT.hpp <CDT.hpp>
>+  @brief CDT[HASH] forward iterator
>+*/
>+class CTPP2DECL CDTIterator
>+{
>+private:
>+	friend class CDT;
>+	friend class CDTConstIterator;
>+
>+	/** Hash iterator */
>+	CDT::Map::iterator itMap;
>+
>+	/**
>+	  @brief Constructor
>+	  @param itIMap - map iterator
>+	*/
>+	CDTIterator(CDT::Map::iterator itIMap);
>+public:
>+	/**
>+	  @brief Copy constructor
>+	  @param oRhs - object to copy
>+	*/
>+	CDTIterator(const CDTIterator & oRhs);
>+
>+	/**
>+	  @brief Operator =
>+	  @param oRhs - object to copy
>+	*/
>+	CDTIterator & operator=(const CDTIterator & oRhs);
>+
>+	/**
>+	  @brief Pre-increment operator ++
>+	*/
>+	CDTIterator & operator++();
>+
>+	/**
>+	  @brief Post-increment operator ++
>+	*/
>+	CDTIterator operator++(int);
>+
>+	/**
>+	  @brief Access operator
>+	  @return Pair of key => value
>+	*/
>+	STLW::pair<const STLW::string, CDT> * operator->();
>+
>+	/**
>+	  @brief Comparison operator
>+	  @param oRhs - object to compare
>+	  @return true if objects are equal
>+	*/
>+	bool operator ==(const CDTIterator & oRhs);
>+
>+	/**
>+	  @brief Comparison operator
>+	  @param oRhs - object to compare
>+	  @return true if objects are NOT equal
>+	*/
>+	bool operator !=(const CDTIterator & oRhs);
>+};
>+
>+
>+/**
>+  @class CDTConstIterator CDT.hpp <CDT.hpp>
>+  @brief CDT[HASH] forward constant iterator
>+*/
>+class CTPP2DECL CDTConstIterator
>+{
>+private:
>+	friend class CDT;
>+
>+	/** Hash iterator */
>+	CDT::Map::const_iterator itMap;
>+
>+public:
>+	/**
>+	  @brief Copy constructor
>+	  @param oRhs - object to copy
>+	*/
>+	CDTConstIterator(const CDTConstIterator & oRhs);
>+
>+	/**
>+	  @brief Type cast constructor
>+	  @param oRhs - object to copy
>+	*/
>+	CDTConstIterator(const CDTIterator & oRhs);
>+
>+	/**
>+	  @brief Operator =
>+	  @param oRhs - object to copy
>+	*/
>+	CDTConstIterator & operator=(const CDTConstIterator & oRhs);
>+
>+	/**
>+	  @brief Operator =
>+	  @param oRhs - object to copy
>+	*/
>+	CDTConstIterator & operator=(const CDTIterator & oRhs);
>+
>+	/**
>+	  @brief Pre-increment operator ++
>+	*/
>+	CDTConstIterator & operator++();
>+
>+	/**
>+	  @brief Post-increment operator ++
>+	*/
>+	CDTConstIterator operator++(int);
>+
>+	/**
>+	  @brief Access operator
>+	  @return Pair of key => value
>+	*/
>+	const STLW::pair<const STLW::string, CDT> * operator->() const;
>+
>+	/**
>+	  @brief Comparison operator
>+	  @param oRhs - object to compare
>+	  @return true if objects are equal
>+	*/
>+	bool operator ==(const CDTConstIterator & oRhs) const;
>+
>+	/**
>+	  @brief Comparison operator
>+	  @param oRhs - object to compare
>+	  @return true if objects are NOT equal
>+	*/
>+	bool operator !=(const CDTConstIterator & oRhs) const;
>+};
>+
>+
> // ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
> //
> // Realization
>
>--- ../../ctpp2.orig/src/CDT.cpp	2012-11-10 23:38:03.000000000 +0400
>+++ ../src/CDT.cpp	2014-04-30 14:18:22.000000000 +0400
>@@ -108,17 +108,17 @@
> //
> // Constructor
> //
>-CDT::Iterator::Iterator(CDT::Map::iterator itIMap): itMap(itIMap) { ;; }
>+CDTIterator::CDTIterator(CDT::Map::iterator itIMap): itMap(itIMap) { ;; }
> 
> //
> // Copy constructor
> //
>-CDT::Iterator::Iterator(const CDT::Iterator & oRhs): itMap(oRhs.itMap) { ;; }
>+CDTIterator::CDTIterator(const CDTIterator & oRhs): itMap(oRhs.itMap) { ;; }
> 
> //
> // Operator =
> //
>-CDT::Iterator & CDT::Iterator::operator=(const CDT::Iterator & oRhs)
>+CDTIterator & CDTIterator::operator=(const CDTIterator & oRhs)
> {
> 	if (this != &oRhs) { itMap = oRhs.itMap; }
> 
>@@ -128,7 +128,7 @@
> //
> // Pre-increment operator ++
> //
>-CDT::Iterator & CDT::Iterator::operator++()
>+CDTIterator & CDTIterator::operator++()
> {
> 	++itMap;
> 
>@@ -138,9 +138,9 @@
> //
> // Post-increment operator ++
> //
>-CDT::Iterator CDT::Iterator::operator++(int)
>+CDTIterator CDTIterator::operator++(int)
> {
>-	Iterator oTMP = *this;
>+	CDTIterator oTMP = *this;
> 
> 	++itMap;
> 
>@@ -150,46 +150,46 @@
> //
> // Access operator
> //
>-STLW::pair<const STLW::string, CDT> * CDT::Iterator::operator->() { return &(*itMap); }
>+STLW::pair<const STLW::string, CDT> * CDTIterator::operator->() { return &(*itMap); }
> 
> //
> // Comparison operator
> //
>-bool CDT::Iterator::operator ==(const CDT::Iterator & oRhs) { return (itMap == oRhs.itMap); }
>+bool CDTIterator::operator ==(const CDTIterator & oRhs) { return (itMap == oRhs.itMap); }
> 
> //
> // Comparison operator
> //
>-bool CDT::Iterator::operator !=(const CDT::Iterator & oRhs) { return (itMap != oRhs.itMap); }
>+bool CDTIterator::operator !=(const CDTIterator & oRhs) { return (itMap != oRhs.itMap); }
> 
> //
> // Get iterator pointed to start of hash
> //
>-CDT::Iterator CDT::Begin()
>+CDTIterator CDT::Begin()
> {
> 	if (eValueType != HASH_VAL) { throw CDTAccessException(); }
> 
>-return Iterator(u.p_data -> u.m_data -> begin());
>+return CDTIterator(u.p_data -> u.m_data -> begin());
> }
> 
> //
> // Get iterator pointed to end of hash
> //
>-CDT::Iterator CDT::End()
>+CDTIterator CDT::End()
> {
> 	if (eValueType != HASH_VAL) { throw CDTAccessException(); }
> 
>-	return Iterator(u.p_data -> u.m_data -> end());
>+	return CDTIterator(u.p_data -> u.m_data -> end());
> }
> 
> //
> // Find element in hash
> //
>-CDT::Iterator CDT::Find(const STLW::string & sKey)
>+CDTIterator CDT::Find(const STLW::string & sKey)
> {
> 	if (eValueType != HASH_VAL) { throw CDTAccessException(); }
> 
>-return Iterator(u.p_data -> u.m_data -> find(sKey));
>+return CDTIterator(u.p_data -> u.m_data -> find(sKey));
> }
> 
> // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
>@@ -200,17 +200,17 @@
> //
> // Copy constructor
> //
>-CDT::ConstIterator::ConstIterator(const CDT::ConstIterator & oRhs): itMap(oRhs.itMap) { ;; }
>+CDTConstIterator::CDTConstIterator(const CDTConstIterator & oRhs): itMap(oRhs.itMap) { ;; }
> 
> //
> // Type cast constructor
> //
>-CDT::ConstIterator::ConstIterator(const CDT::Iterator & oRhs): itMap(oRhs.itMap) { ;; }
>+CDTConstIterator::CDTConstIterator(const CDTIterator & oRhs): itMap(oRhs.itMap) { ;; }
> 
> //
> // Operator =
> //
>-CDT::ConstIterator & CDT::ConstIterator::operator=(const ConstIterator & oRhs)
>+CDTConstIterator & CDTConstIterator::operator=(const CDTConstIterator & oRhs)
> {
> 	if (this != &oRhs) { itMap = oRhs.itMap; }
> 
>@@ -220,7 +220,7 @@
> //
> // Operator =
> //
>-CDT::ConstIterator & CDT::ConstIterator::operator=(const CDT::Iterator & oRhs)
>+CDTConstIterator & CDTConstIterator::operator=(const CDTIterator & oRhs)
> {
> 	itMap = oRhs.itMap;
> 
>@@ -230,7 +230,7 @@
> //
> // Pre-increment operator ++
> //
>-CDT::ConstIterator & CDT::ConstIterator::operator++()
>+CDTConstIterator & CDTConstIterator::operator++()
> {
> 	++itMap;
> 
>@@ -240,9 +240,9 @@
> //
> // Post-increment operator ++
> //
>-CDT::ConstIterator CDT::ConstIterator::operator++(int)
>+CDTConstIterator CDTConstIterator::operator++(int)
> {
>-	ConstIterator oTMP = *this;
>+	CDTConstIterator oTMP = *this;
> 
> 	++itMap;
> 
>@@ -252,46 +252,46 @@
> //
> // Access operator
> //
>-const STLW::pair<const STLW::string, CDT> * CDT::ConstIterator::operator->() const { return &(*itMap); }
>+const STLW::pair<const STLW::string, CDT> * CDTConstIterator::operator->() const { return &(*itMap); }
> 
> //
> // Comparison operator
> //
>-bool CDT::ConstIterator::operator ==(const CDT::ConstIterator & oRhs) const { return (itMap == oRhs.itMap); }
>+bool CDTConstIterator::operator ==(const CDTConstIterator & oRhs) const { return (itMap == oRhs.itMap); }
> 
> //
> // Comparison operator
> //
>-bool CDT::ConstIterator::operator !=(const CDT::ConstIterator & oRhs) const { return (itMap != oRhs.itMap); }
>+bool CDTConstIterator::operator !=(const CDTConstIterator & oRhs) const { return (itMap != oRhs.itMap); }
> 
> //
> // Get constant iterator pointed to start of hash
> //
>-CDT::ConstIterator CDT::Begin() const
>+CDTConstIterator CDT::Begin() const
> {
> 	if (eValueType != HASH_VAL) { throw CDTAccessException(); }
> 
>-return ConstIterator(u.p_data -> u.m_data -> begin());
>+return CDTConstIterator(u.p_data -> u.m_data -> begin());
> }
> 
> //
> // Get constant iterator pointed to end of hash
> //
>-CDT::ConstIterator CDT::End() const
>+CDTConstIterator CDT::End() const
> {
> 	if (eValueType != HASH_VAL) { throw CDTAccessException(); }
> 
>-return ConstIterator(u.p_data -> u.m_data -> end());
>+return CDTConstIterator(u.p_data -> u.m_data -> end());
> }
> 
> //
> // Find element in hash
> //
>-CDT::ConstIterator CDT::Find(const STLW::string & sKey) const
>+CDTConstIterator CDT::Find(const STLW::string & sKey) const
> {
> 	if (eValueType != HASH_VAL) { throw CDTAccessException(); }
> 
>-return ConstIterator(u.p_data -> u.m_data -> find(sKey));
>+return CDTConstIterator(u.p_data -> u.m_data -> find(sKey));
> }
> 
> // ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
>@@ -4138,7 +4138,7 @@
> 
> 		case HASH_VAL:
> 			{
>-				ConstIterator itHash = oData.Begin();
>+				CDTConstIterator itHash = oData.Begin();
> 				if (itHash == oData.End())
> 				{
> 					if (!bGlobalScope) { sResult += "{ }"; }
>
>--- ../../ctpp2.orig/src/CTPP2FileSourceLoader.cpp	2012-08-02 11:22:44.000000000 +0400
>+++ ../src/CTPP2FileSourceLoader.cpp	2014-04-30 14:21:03.000000000 +0400
>@@ -38,6 +38,7 @@
> #include <errno.h>
> #include <stdio.h>
> #include <stdlib.h>
>+#include <unistd.h>
> 
> #ifdef WIN32
>     #include <direct.h> /* getcwd */
>
>--- ../../ctpp2.orig/src/CTPP2Util.cpp	2012-08-02 11:22:44.000000000 +0400
>+++ ../src/CTPP2Util.cpp	2014-04-30 14:24:32.000000000 +0400
>@@ -751,7 +751,7 @@
> 		case CDT::HASH_VAL:
> 			{
> 				oResult.Write("{", 1);
>-				CDT::ConstIterator itCDTCArray = oCDT.Begin();
>+				CDTConstIterator itCDTCArray = oCDT.Begin();
> 				while (itCDTCArray != oCDT.End())
> 				{
> 					oResult.Write("\"", 1);
>
>--- ../../ctpp2.orig/src/CTPP2VM.cpp	2012-08-02 11:22:44.000000000 +0400
>+++ ../src/CTPP2VM.cpp	2014-04-30 14:25:49.000000000 +0400
>@@ -1440,7 +1440,7 @@
> 
>                                             if (oRegs[iSrcReg].GetType() == CDT::HASH_VAL)
>                                             {
>-                                                CDT::Iterator it = oRegs[iSrcReg].Begin();
>+                                                CDTIterator it = oRegs[iSrcReg].Begin();
>                                                 for (INT_32 iI = 0; iI < iIdx; ++iI) { ++it; }
> #ifdef _DEBUG
> fprintf(stderr, "(`%s`): %s\n", it->first.c_str(), it->second.GetString().c_str());
>
>--- ../../ctpp2.orig/tests/CDTTest.cpp	2012-08-02 11:22:44.000000000 +0400
>+++ ../tests/CDTTest.cpp	2014-04-30 14:27:19.000000000 +0400
>@@ -590,7 +590,7 @@
> 
> 	fprintf(stderr, "Get HASH values: %s\n", oCDT_array.GetHashValues().Dump().c_str());
> 
>-	CDT::Iterator itCDTArray = oCDT_array.Begin();
>+	CDTIterator itCDTArray = oCDT_array.Begin();
> 	while (itCDTArray != oCDT_array.End())
> 	{
> 		fprintf(stderr, "oCDT_array[\"%s\"] => %s\n", itCDTArray -> first.c_str(), itCDTArray -> second.GetString().c_str());
>@@ -598,7 +598,7 @@
> 		++itCDTArray;
> 	}
> 
>-	CDT::ConstIterator itCDTCArray = oCDT_array.Begin();
>+	CDTConstIterator itCDTCArray = oCDT_array.Begin();
> 	while (itCDTCArray != oCDT_array.End())
> 	{
> 		fprintf(stderr, "oCDT_array[\"%s\"] => %s\n", itCDTCArray -> first.c_str(), itCDTCArray -> second.GetString().c_str());

Actions: View | Diff

Attachments on bug 189134: 142151