fix forward_tree iterators

alib2std/src/extensions/forward_tree.hpp

@@ -178,6 +178,7 @@ public:
 					const tree_node * parent = parents.back ( );
 					if ( node == parent->getChildren ( ).end ( ) ) {
+						parents.pop_back();
 						--level;
 						node = typename std::vector < tree_node >::const_iterator ( parent );
 					} else {
@@ -193,9 +194,9 @@ public:
 				if ( newIter != node->getChildren ( ).end ( ) ) {
 					++level;
-					node = newIter;
 					parents.push_back ( & * node );
+					node = newIter;
 				} else {
 					virtual_node = true;
 				}
@@ -221,10 +222,10 @@ public:
 				if ( newIter != node->getChildren ( ).begin ( ) ) {
 					++level;
-					node = newIter;
-					--node;
 					parents.push_back ( & * node );
+					node = newIter;
+					--node;
 				} else {
 					virtual_node = false;
 				}
@@ -233,6 +234,7 @@ public:
 					const tree_node * parent = parents.back ( );
 					if ( node == parent->getChildren ( ).begin ( ) ) {
+						parents.pop_back();
 						--level;
 						node = typename std::vector < tree_node >::const_iterator ( parent );
 					} else {
@@ -584,7 +586,7 @@ public:
 		return res;
 	}
-	// --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 	template < class ... Indexes >
 	const T & operator ()( Indexes ... indexes ) const {
@@ -655,6 +657,7 @@ public:
 	}
 // ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
 	int compare ( const forward_tree & other ) const {
 		std::compare < typename std::decay < T >::type > comp;
 		auto iterF = this->prefix_begin ( );

alib2std/src/extensions/tree.hpp

@@ -611,7 +611,7 @@ public:
 		return res;
 	}
-	// --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 	template < class ... Indexes >
 	const T & operator ()( Indexes ... indexes ) const {
@@ -697,6 +697,7 @@ public:
 	}
 // ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
 	int compare ( const tree & other ) const {
 		std::compare < typename std::decay < T >::type > comp;
 		auto iterF = this->prefix_begin ( );

alib2std/test-src/extensions/ForwardTreeTest.cpp

@@ -9,37 +9,29 @@ void ForwardTreeTest::setUp ( ) {
 void ForwardTreeTest::tearDown ( ) {
 }
-void ForwardTreeTest::print_tree ( std::tree < char >::const_children_iterator biter, std::tree < char >::const_children_iterator eiter, std::string indent ) {
-	for ( std::tree < char >::const_children_iterator iter = biter; iter != eiter; iter++ ) {
+void ForwardTreeTest::print_tree ( std::forward_tree < char >::const_children_iterator biter, std::forward_tree < char >::const_children_iterator eiter, std::string indent ) {
+	for ( std::forward_tree < char >::const_children_iterator iter = biter; iter != eiter; iter++ ) {
 		std::cout << indent << * iter << std::endl;
 		print_tree ( iter.begin ( ), iter.end ( ), indent + " " );
 	}
 }
 void ForwardTreeTest::testTreeStdStructure ( ) {
-	std::tree < char > t ( 'a', std::tree < char > ( 'a' ), std::tree < char > ( 'b', std::tree < char > ( 'a' ), std::tree < char > ( 'b' ) ) );
-	// std::cout << "structure t " << std::boolalpha << t.checkStructure() << std::endl;
-	std::tree < char > t2 ( 'c' );
-
-	 // std::cout << "structure t2 " << std::boolalpha << t2.checkStructure() << std::endl;
-	t2.insert ( t2.begin ( ), t2.begin ( ).begin ( ), { 'c', std::tree < char > ( 'b' ) } );
-	CPPUNIT_ASSERT ( t2.checkStructure ( ) );
+	std::forward_tree < char > t ( 'a', std::forward_tree < char > ( 'a' ), std::forward_tree < char > ( 'b', std::forward_tree < char > ( 'a' ), std::forward_tree < char > ( 'b' ) ) );
+	std::forward_tree < char > t2 ( 'c' );
+	t2.insert ( t2.begin ( ), t2.begin ( ).begin ( ), { 'c', std::forward_tree < char > ( 'b' ) } );
 	t2.insert ( t2.begin ( ), t2.begin ( ).end ( ), t.begin ( ), t.end ( ) );
-	CPPUNIT_ASSERT ( t2.checkStructure ( ) );
 	std::vector < char > data = { 'd', 'e' };
 	t2.insert ( t2.begin ( ), t2.begin ( ).end ( ), data.begin ( ), data.end ( ) );
-	CPPUNIT_ASSERT ( t2.checkStructure ( ) );
 	// print_tree ( t.begin(), t.end(), "");
 	t2.erase ( t2.begin ( ), std::prev ( t2.begin ( ).end ( ) ) );
-	CPPUNIT_ASSERT ( t2.checkStructure ( ) );
 	t2.push_back ( t2.begin ( ), 'f' );
-	CPPUNIT_ASSERT ( t2.checkStructure ( ) );
 	// print_tree ( t2.begin(), t2.end(), "");
@@ -47,8 +39,7 @@ void ForwardTreeTest::testTreeStdStructure ( ) {
 	t2 ( 1, 1 ) = 'c';
 	CPPUNIT_ASSERT_EQUAL ( ( char ) t2 ( 1, 1 ), 'c' );
-	CPPUNIT_ASSERT ( t2.checkStructure ( ) );
-	std::tree < char >::const_prefix_iterator beg = t2.prefix_begin ( );
+	std::forward_tree < char >::const_prefix_iterator beg = t2.prefix_begin ( );
 	beg++;
 	beg++;
 	beg++;
@@ -73,7 +64,7 @@ void ForwardTreeTest::testTreeStdStructure ( ) {
 	std::vector < std::pair < unsigned, char > > expectedPrefix = { { 0, 'c' }, { 1, 'c' }, { 2, 'b' }, { 1, 'a' }, { 2, 'a' }, { 2, 'c' }, { 3, 'a' }, { 3, 'b' }, { 1, 'd' }, { 1, 'f' } };
 	std::vector < std::pair < unsigned, char > >::const_iterator ref = expectedPrefix.begin ( );
-	for ( std::tree < char >::const_prefix_iterator iter = t2.prefix_begin ( ); iter != t2.prefix_end ( ); ++iter ) {
+	for ( std::forward_tree < char >::const_prefix_iterator iter = t2.prefix_begin ( ); iter != t2.prefix_end ( ); ++iter ) {
 		CPPUNIT_ASSERT ( iter.getLevel ( ) == ref->first );
 		CPPUNIT_ASSERT ( * iter == ref->second );
 		++iter;
@@ -84,7 +75,7 @@ void ForwardTreeTest::testTreeStdStructure ( ) {
 	std::vector < std::tuple < unsigned, char, bool > > expectedStructure = { std::make_tuple ( 0u, 'c', false ), std::make_tuple ( 1u, 'c', false ), std::make_tuple ( 2u, 'b', false ), std::make_tuple ( 2u, 'b', true ), std::make_tuple ( 1u, 'c', true ), std::make_tuple ( 1u, 'a', false ), std::make_tuple ( 2u, 'a', false ), std::make_tuple ( 2u, 'a', true ), std::make_tuple ( 2u, 'c', false ), std::make_tuple ( 3u, 'a', false ), std::make_tuple ( 3u, 'a', true ), std::make_tuple ( 3u, 'b', false ), std::make_tuple ( 3u, 'b', true ), std::make_tuple ( 2u, 'c', true ), std::make_tuple ( 1u, 'a', true ), std::make_tuple ( 1u, 'd', false ), std::make_tuple ( 1u, 'd', true ), std::make_tuple ( 1u, 'f', false ), std::make_tuple ( 1u, 'f', true ), std::make_tuple ( 0u, 'c', true ) };
 	std::vector < std::tuple < unsigned, char, bool > >::const_iterator ref2 = expectedStructure.begin ( );
-	for ( std::tree < char >::const_structure_iterator iter = t2.structure_begin ( ); iter != t2.structure_end ( ); ++iter ) {
+	for ( std::forward_tree < char >::const_structure_iterator iter = t2.structure_begin ( ); iter != t2.structure_end ( ); ++iter ) {
 		CPPUNIT_ASSERT ( iter.getLevel ( ) == std::get < 0 > ( * ref2 ) );
 		CPPUNIT_ASSERT ( * iter == std::get < 1 > ( * ref2 ) );
 		CPPUNIT_ASSERT ( iter.getVirtual ( ) == std::get < 2 > ( * ref2 ) );
@@ -96,7 +87,7 @@ void ForwardTreeTest::testTreeStdStructure ( ) {
 	std::vector < std::pair < unsigned, char > > expectedPostfix = { { 2, 'b' }, { 1, 'c' }, { 2, 'a' }, { 3, 'a' }, { 3, 'b' }, { 2, 'c' }, { 1, 'a' }, { 1, 'd' }, { 1, 'f' }, { 0, 'c' } };
 	std::vector < std::pair < unsigned, char > >::const_iterator ref3 = expectedPostfix.begin ( );
-	for ( std::tree < char >::const_postfix_iterator iter = t2.postfix_begin ( ); iter != t2.postfix_end ( ); ++iter ) {
+	for ( std::forward_tree < char >::const_postfix_iterator iter = t2.postfix_begin ( ); iter != t2.postfix_end ( ); ++iter ) {
 		CPPUNIT_ASSERT ( iter.getLevel ( ) == ref3->first );
 		CPPUNIT_ASSERT ( * iter == ref3->second );
 		++iter;
@@ -104,36 +95,33 @@ void ForwardTreeTest::testTreeStdStructure ( ) {
 		++ref3;
 	}
-	std::tree < char, RankedArityChecker > rt ( 'a', std::tree < char, RankedArityChecker > ( 'b', std::tree < char, RankedArityChecker > ( 'c' ) ), std::tree < char, RankedArityChecker > ( 'c' ) );
+	std::forward_tree < char, RankedArityChecker > rt ( 'a', std::forward_tree < char, RankedArityChecker > ( 'b', std::forward_tree < char, RankedArityChecker > ( 'c' ) ), std::forward_tree < char, RankedArityChecker > ( 'c' ) );
 	CPPUNIT_ASSERT_EQUAL ( ( char ) rt ( 0, 0 ), 'c' );
 	rt ( 0, 0 ) = 'd';
 	CPPUNIT_ASSERT_EQUAL ( ( char ) rt ( 0, 0 ), 'd' );
-	rt ( 0, 0 ) = std::tree < char, RankedArityChecker > ( 'e' );
+	rt ( 0, 0 ) = std::forward_tree < char, RankedArityChecker > ( 'e' );
 	CPPUNIT_ASSERT_EQUAL ( ( char ) rt ( 0, 0 ), 'e' );
-	CPPUNIT_ASSERT ( rt.checkStructure ( ) );
 	std::cout << rt << std::endl;
 	swap ( rt ( 0 ), rt ( 1 ) );
-	CPPUNIT_ASSERT ( rt.checkStructure ( ) );
 	std::cout << rt << std::endl;
 	std::stringstream ss2;
 	ss2 << rt;
 	CPPUNIT_ASSERT ( ss2.str ( ) == "[0a[1c,1b[2e]]]" );
-	std::tree < char, RankedArityChecker > rt2 ( 'c' );
+	std::forward_tree < char, RankedArityChecker > rt2 ( 'c' );
 	swap ( rt, rt2 );
-	CPPUNIT_ASSERT ( rt.checkStructure ( ) );
 	std::cout << rt << std::endl;
 	std::stringstream ss3;
 	ss3 << rt;
 	CPPUNIT_ASSERT ( ss3.str ( ) == "[0c]" );
 	std::cout << rt2 << std::endl;
-	std::tree < char > cmp1 ( 'a' );
-	std::tree < char > cmp2 ( 'b' );
-	std::tree < char > cmp3 ( 'c' );
+	std::forward_tree < char > cmp1 ( 'a' );
+	std::forward_tree < char > cmp2 ( 'b' );
+	std::forward_tree < char > cmp3 ( 'c' );
 	CPPUNIT_ASSERT ( cmp1 < cmp2 );
 	CPPUNIT_ASSERT ( cmp2 < cmp3 );

alib2std/test-src/extensions/ForwardTreeTest.h

@@ -28,7 +28,7 @@ public:
 	};
-	void print_tree ( std::tree < char >::const_children_iterator biter, std::tree < char >::const_children_iterator eiter, std::string indent );
+	void print_tree ( std::forward_tree < char >::const_children_iterator biter, std::forward_tree < char >::const_children_iterator eiter, std::string indent );
 	void setUp ( );
 	void tearDown ( );