[Boost-commit] svn:boost r48828 - sandbox/SOC/2006/tree/trunk/boost/tree

Subject: [Boost-commit] svn:boost r48828 - sandbox/SOC/2006/tree/trunk/boost/tree
From: ockham_at_[hidden]
Date: 2008-09-17 18:05:39

Author: bernhard.reiter
Date: 2008-09-17 18:05:38 EDT (Wed, 17 Sep 2008)
New Revision: 48828
URL: http://svn.boost.org/trac/boost/changeset/48828

Log:
Replace tabs by spaces.
Text files modified: 
   sandbox/SOC/2006/tree/trunk/boost/tree/cursor.hpp         |   138 +++++++++---------                      
   sandbox/SOC/2006/tree/trunk/boost/tree/cursor_adaptor.hpp |   292 ++++++++++++++++++++--------------------
   sandbox/SOC/2006/tree/trunk/boost/tree/cursor_facade.hpp  |   268 ++++++++++++++++++------------------    
   sandbox/SOC/2006/tree/trunk/boost/tree/forest_tree.hpp    |   138 +++++++++---------                      
   sandbox/SOC/2006/tree/trunk/boost/tree/graph.hpp          |    76 +++++-----                              
   5 files changed, 456 insertions(+), 456 deletions(-)

Modified: sandbox/SOC/2006/tree/trunk/boost/tree/cursor.hpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/boost/tree/cursor.hpp	(original)
+++ sandbox/SOC/2006/tree/trunk/boost/tree/cursor.hpp	2008-09-17 18:05:38 EDT (Wed, 17 Sep 2008)
@@ -27,58 +27,58 @@
 
 template <class Cursor>
 struct cursor_value {
-	typedef typename Cursor::value_type type;
+    typedef typename Cursor::value_type type;
 };
 
 template <class Cursor>
 struct cursor_reference {
-	typedef typename Cursor::reference type;
+    typedef typename Cursor::reference type;
 };
 
 template <class Cursor>
 struct cursor_const_reference {
-	typedef typename Cursor::const_reference type;
+    typedef typename Cursor::const_reference type;
 };
 
 template <class Cursor>
 struct cursor_pointer {
-	typedef typename Cursor::pointer type;
+    typedef typename Cursor::pointer type;
 };
 
 template <class Cursor>
 struct cursor_difference {
-	typedef typename Cursor::difference_type type;
+    typedef typename Cursor::difference_type type;
 };
 
 template <class Cursor>
 struct cursor_size {
-	typedef typename Cursor::size_type type;
+    typedef typename Cursor::size_type type;
 };
 
 template <class Cursor>
 struct cursor_category {
-	typedef typename Cursor::cursor_category type;
+    typedef typename Cursor::cursor_category type;
 };
 
 template <class Cursor>
 struct cursor_horizontal_traversal {
-	typedef typename Cursor::horizontal_traversal type;
+    typedef typename Cursor::horizontal_traversal type;
 };
 
 template <class Cursor>
 struct cursor_vertical_traversal {
-	typedef typename Cursor::vertical_traversal type;
+    typedef typename Cursor::vertical_traversal type;
 };
 
 template <class Cat, class T, class Dist = ptrdiff_t, class Size = size_t,
-		  class Ptr = T*, class Ref = T&>
+          class Ptr = T*, class Ref = T&>
 struct cursor {
-	typedef Cat		cursor_category;
-	typedef T		value_type;
-	typedef Dist	difference_type;
-	typedef Size	size_type;
-	typedef Ptr		pointer;
-	typedef Ref		reference;	
+    typedef Cat        cursor_category;
+    typedef T        value_type;
+    typedef Dist    difference_type;
+    typedef Size    size_type;
+    typedef Ptr        pointer;
+    typedef Ref        reference;    
 };
 
 // Deprecate?
@@ -86,24 +86,24 @@
 
 struct descending_tag {}; 
 struct descending_cursor_tag
-	: public cursor_tag, public descending_tag, 
-	  public input_iterator_tag, public output_iterator_tag {};
+    : public cursor_tag, public descending_tag, 
+      public input_iterator_tag, public output_iterator_tag {};
 struct descending_forward_cursor_tag
-	: public cursor_tag, public descending_tag, public forward_iterator_tag {};
+    : public cursor_tag, public descending_tag, public forward_iterator_tag {};
 struct descending_bidirectional_cursor_tag
-	: public cursor_tag, public descending_tag, public bidirectional_iterator_tag {};
+    : public cursor_tag, public descending_tag, public bidirectional_iterator_tag {};
 struct descending_random_access_cursor_tag
-	: public cursor_tag, public descending_tag, public random_access_iterator_tag {};
+    : public cursor_tag, public descending_tag, public random_access_iterator_tag {};
 
 struct ascending_tag {};
 struct ascending_cursor_tag
-	: public descending_cursor_tag, public ascending_tag {};
+    : public descending_cursor_tag, public ascending_tag {};
 struct ascending_forward_cursor_tag
-	: public descending_forward_cursor_tag, public ascending_tag {};
+    : public descending_forward_cursor_tag, public ascending_tag {};
 struct ascending_bidirectional_cursor_tag
-	: public descending_bidirectional_cursor_tag, public ascending_tag {};
+    : public descending_bidirectional_cursor_tag, public ascending_tag {};
 struct ascending_random_access_cursor_tag
-	: public descending_random_access_cursor_tag, public ascending_tag {};
+    : public descending_random_access_cursor_tag, public ascending_tag {};
 
 /*
 template <class Hor, class Vert>
@@ -111,7 +111,7 @@
 
 template <>
 struct produce_cursor_category<> {
-	typedef descending_cursor_tag type;
+    typedef descending_cursor_tag type;
 };
 */
 
@@ -130,52 +130,52 @@
 template<class OutputIterator>
 class output_cursor_iterator_wrapper {
 protected:
-	OutputIterator* iter;
+    OutputIterator* iter;
 public:
-	/// Make the iterator type publicly accessible.
-	typedef OutputIterator iterator;
-	
-	/**
-	 * For construction, we obviously need an Output Iterator to work on (i.e., write to).
-	 */
-	explicit output_cursor_iterator_wrapper(OutputIterator& i) : iter(&i) {}
-
-	/** 
-	 * @param value A const& value of the value_type of container that iter is
-	 *              associated with.
-	 * @return      This cursor, for chained operations.
-	 * Assigning a value to this cursor will insert it before iter, the iterator it is
-	 * wrapped around.
-	 * 
-	 * Unfortunately, Output Iterators do not necessarily expose their
-	 * value_type (they might just give back void), so the following assignment operator
-	 * has to be a template.
-	 */
-	// TODO: Consult C++0x if this has been changed
-	template <class ValueType>
-	output_cursor_iterator_wrapper& operator=(ValueType const& value)
-	{ 
-		*((*iter)++) = value;
-		return *this; 
-	}
-
-	/// Returns *this.
-	output_cursor_iterator_wrapper& operator*() { return *this; }
-
-	/// Returns *this, as this %cursor doesn't "move".
-	output_cursor_iterator_wrapper& operator++() { return *this; }
-
-	/// Returns *this, as this %cursor doesn't "move".
-	output_cursor_iterator_wrapper operator++(int) { return *this; }
-
-	/// Returns *this, as this %cursor doesn't "move".
-	output_cursor_iterator_wrapper& to_begin() { return *this; }
-	output_cursor_iterator_wrapper& begin() { return *this; }
+    /// Make the iterator type publicly accessible.
+    typedef OutputIterator iterator;
+    
+    /**
+     * For construction, we obviously need an Output Iterator to work on (i.e., write to).
+     */
+    explicit output_cursor_iterator_wrapper(OutputIterator& i) : iter(&i) {}
+
+    /** 
+     * @param value A const& value of the value_type of container that iter is
+     *              associated with.
+     * @return      This cursor, for chained operations.
+     * Assigning a value to this cursor will insert it before iter, the iterator it is
+     * wrapped around.
+     * 
+     * Unfortunately, Output Iterators do not necessarily expose their
+     * value_type (they might just give back void), so the following assignment operator
+     * has to be a template.
+     */
+    // TODO: Consult C++0x if this has been changed
+    template <class ValueType>
+    output_cursor_iterator_wrapper& operator=(ValueType const& value)
+    { 
+        *((*iter)++) = value;
+        return *this; 
+    }
+
+    /// Returns *this.
+    output_cursor_iterator_wrapper& operator*() { return *this; }
+
+    /// Returns *this, as this %cursor doesn't "move".
+    output_cursor_iterator_wrapper& operator++() { return *this; }
+
+    /// Returns *this, as this %cursor doesn't "move".
+    output_cursor_iterator_wrapper operator++(int) { return *this; }
+
+    /// Returns *this, as this %cursor doesn't "move".
+    output_cursor_iterator_wrapper& to_begin() { return *this; }
+    output_cursor_iterator_wrapper& begin() { return *this; }
 };
 
 /** 
- * @param o	An output iterator.
- * @result	An instance of output_cursor_iterator_wrapper working on o.
+ * @param o    An output iterator.
+ * @result    An instance of output_cursor_iterator_wrapper working on o.
  * 
  * Use as shortcut for cumbersome typenames, just as with std::inserter and the like.
  */
@@ -183,7 +183,7 @@
 inline output_cursor_iterator_wrapper<OutputIterator>
 outputter_cursor_iterator_wrapper(OutputIterator o)
 {
-	return output_cursor_iterator_wrapper<OutputIterator>(o);
+    return output_cursor_iterator_wrapper<OutputIterator>(o);
 }
 
 //define freestanding begin, end, size, empty using cursor's member fns?

Modified: sandbox/SOC/2006/tree/trunk/boost/tree/cursor_adaptor.hpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/boost/tree/cursor_adaptor.hpp	(original)
+++ sandbox/SOC/2006/tree/trunk/boost/tree/cursor_adaptor.hpp	2008-09-17 18:05:38 EDT (Wed, 17 Sep 2008)
@@ -32,114 +32,114 @@
 template <
     class Derived
   , class Base
-  , class Value               			= use_default
+  , class Value                           = use_default
   , class HorizontalTraversalOrCategory = use_default
-  , class VerticalTraversalOrCategory	= use_default
-  , class Reference           			= use_default
-  , class Difference          			= use_default
-  , class Size                			= use_default
+  , class VerticalTraversalOrCategory    = use_default
+  , class Reference                       = use_default
+  , class Difference                      = use_default
+  , class Size                            = use_default
 >
 class cursor_adaptor_base
 : private iterator_adaptor<Derived 
-  						, Base
-  						, Value
-						, HorizontalTraversalOrCategory
-						, Reference
-						, Difference>
+                          , Base
+                          , Value
+                        , HorizontalTraversalOrCategory
+                        , Reference
+                        , Difference>
 , private iterator_adaptor<Derived 
-  						, Base
-  						, Value
-						, VerticalTraversalOrCategory
-						, Reference
-						, Difference>
+                          , Base
+                          , Value
+                        , VerticalTraversalOrCategory
+                        , Reference
+                        , Difference>
 {
 private:
-	cursor_adaptor_base() {} // This class is used for typedefs only.
-	
-	typedef typename iterator_adaptor<Derived, Base, Value
-								, HorizontalTraversalOrCategory, Reference
-								, Difference>::super_t h_super_t;
-	typedef typename iterator_adaptor<Derived, Base, Value
-								, VerticalTraversalOrCategory, Reference
-								, Difference>::super_t v_super_t;
+    cursor_adaptor_base() {} // This class is used for typedefs only.
+    
+    typedef typename iterator_adaptor<Derived, Base, Value
+                                , HorizontalTraversalOrCategory, Reference
+                                , Difference>::super_t h_super_t;
+    typedef typename iterator_adaptor<Derived, Base, Value
+                                , VerticalTraversalOrCategory, Reference
+                                , Difference>::super_t v_super_t;
 public:
-	typedef typename h_super_t::value_type value_type;	
-	typedef typename h_super_t::reference reference;
-	typedef typename h_super_t::difference_type difference_type;
-	typedef typename h_super_t::pointer pointer;
-	typedef typename h_super_t::iterator_category iterator_category;
-	typedef typename v_super_t::iterator_category vertical_traversal;
-	
-	// size_type isn't in iterator_adaptor or _facade, 
-	// so we have to calculate it on our own: 
-	typedef typename mpl::eval_if<
-		is_same<Size, use_default>
-	  , boost::tree::cursor_size<Base>
-	  , mpl::identity<Size>
-	>::type size_type;
-	
-	typedef cursor_facade<Derived
-						, value_type
-						, iterator_category
-						, vertical_traversal
-						, reference
-						, difference_type
-						, size_type> type;
+    typedef typename h_super_t::value_type value_type;    
+    typedef typename h_super_t::reference reference;
+    typedef typename h_super_t::difference_type difference_type;
+    typedef typename h_super_t::pointer pointer;
+    typedef typename h_super_t::iterator_category iterator_category;
+    typedef typename v_super_t::iterator_category vertical_traversal;
+    
+    // size_type isn't in iterator_adaptor or _facade, 
+    // so we have to calculate it on our own: 
+    typedef typename mpl::eval_if<
+        is_same<Size, use_default>
+      , boost::tree::cursor_size<Base>
+      , mpl::identity<Size>
+    >::type size_type;
+    
+    typedef cursor_facade<Derived
+                        , value_type
+                        , iterator_category
+                        , vertical_traversal
+                        , reference
+                        , difference_type
+                        , size_type> type;
 };
 
 template <
     class Derived
   , class Base
-  , class Value               			= use_default
+  , class Value                           = use_default
   , class HorizontalTraversalOrCategory = use_default
-  , class VerticalTraversalOrCategory	= use_default
-  , class Reference           			= use_default
-  , class Difference          			= use_default
-  , class Size                			= use_default
+  , class VerticalTraversalOrCategory    = use_default
+  , class Reference                       = use_default
+  , class Difference                      = use_default
+  , class Size                            = use_default
 >
 class cursor_adaptor 
 : public cursor_adaptor_base< Derived
-							, Base
-							, Value
-							, HorizontalTraversalOrCategory
-							, VerticalTraversalOrCategory
-							, Reference
-							, Difference
-							, Size >::type
+                            , Base
+                            , Value
+                            , HorizontalTraversalOrCategory
+                            , VerticalTraversalOrCategory
+                            , Reference
+                            , Difference
+                            , Size >::type
 {
 protected:
     typedef cursor_adaptor<Derived, Base, Value, HorizontalTraversalOrCategory,
-    					   VerticalTraversalOrCategory, Reference, Difference,
-    					   Size> cursor_adaptor_;
-	
-	typedef typename cursor_adaptor_base<Derived, Base, Value 
-									   , HorizontalTraversalOrCategory
-									   , VerticalTraversalOrCategory
-									   , Reference
-									   , Difference
-									   , Size>::type cursor_facade_;
-	
-	Base const& base_reference() const
-	{ return m_cursor; }
-	
-	Base& base_reference()
-	{ return m_cursor; }
-	
+                           VerticalTraversalOrCategory, Reference, Difference,
+                           Size> cursor_adaptor_;
+    
+    typedef typename cursor_adaptor_base<Derived, Base, Value 
+                                       , HorizontalTraversalOrCategory
+                                       , VerticalTraversalOrCategory
+                                       , Reference
+                                       , Difference
+                                       , Size>::type cursor_facade_;
+    
+    Base const& base_reference() const
+    { return m_cursor; }
+    
+    Base& base_reference()
+    { return m_cursor; }
+    
 private:
-	Base m_cursor;
-	
-	friend class iterator_core_access;
-	friend class cursor_core_access;
+    Base m_cursor;
+    
+    friend class iterator_core_access;
+    friend class cursor_core_access;
 
 public:
- 	typedef Base base_type;
- 	
- 	typedef typename cursor_facade_::iterator_category iterator_category;
+     typedef Base base_type;
+     
+     typedef typename cursor_facade_::iterator_category iterator_category;
 
     typedef typename cursor_facade_::horizontal_traversal horizontal_traversal;
     typedef typename cursor_facade_::vertical_traversal cursor_category;
     
-	typedef typename cursor_facade_::size_type size_type;
+    typedef typename cursor_facade_::size_type size_type;
  
     cursor_adaptor() {}
     
@@ -149,71 +149,71 @@
     Base const& base() const
     { return m_cursor; }
     
- 	typename cursor_facade_::reference dereference() const
- 	{
- 		return *m_cursor;
- 	}
- 	
- 	void increment()
- 	{
- 		++m_cursor;
- 	}
- 	
- 	void decrement()
- 	{
- 		--m_cursor;
- 	}
- 	
- 	template <class OtherDerived, class OtherCursor, class V, class C, 
- 			  class R, class D, class S>
- 	bool equal(cursor_adaptor<OtherDerived, OtherCursor, 
- 							  V, C, R, D, S> const& x) const
- 	{
- 		return m_cursor == x.base();
- 	}
- 	
- 	template <class OtherDerived, class OtherCursor, class V, class C, 
- 			  class R, class D, class S>
- 	Difference distance_to(cursor_adaptor<OtherDerived, OtherCursor, 
- 							  			  V, C, R, D, S> const& x) const
-	{
-		return x.base() - m_cursor;
-	}
- 	
- 	bool const empty_() const
-	{
-		return m_cursor.empty();
-	}
-	
-	size_type const size_() const
-	{
-		return m_cursor.size();
-	}
-	
-	size_type const max_size_() const
-	{
-		return m_cursor.max_size();
-	}
-
-	size_type const par() const
-	{
-		return m_cursor.parity();
-	}
-
-	void left()
-	{
-		m_cursor.to_begin();
-	}
-
-	void right()
-	{
-		m_cursor.to_end();
-	}
-	
-	void up()
-	{
-		m_cursor.to_parent();
-	}
+     typename cursor_facade_::reference dereference() const
+     {
+         return *m_cursor;
+     }
+     
+     void increment()
+     {
+         ++m_cursor;
+     }
+     
+     void decrement()
+     {
+         --m_cursor;
+     }
+     
+     template <class OtherDerived, class OtherCursor, class V, class C, 
+               class R, class D, class S>
+     bool equal(cursor_adaptor<OtherDerived, OtherCursor, 
+                               V, C, R, D, S> const& x) const
+     {
+         return m_cursor == x.base();
+     }
+     
+     template <class OtherDerived, class OtherCursor, class V, class C, 
+               class R, class D, class S>
+     Difference distance_to(cursor_adaptor<OtherDerived, OtherCursor, 
+                                             V, C, R, D, S> const& x) const
+    {
+        return x.base() - m_cursor;
+    }
+     
+     bool const empty_() const
+    {
+        return m_cursor.empty();
+    }
+    
+    size_type const size_() const
+    {
+        return m_cursor.size();
+    }
+    
+    size_type const max_size_() const
+    {
+        return m_cursor.max_size();
+    }
+
+    size_type const par() const
+    {
+        return m_cursor.parity();
+    }
+
+    void left()
+    {
+        m_cursor.to_begin();
+    }
+
+    void right()
+    {
+        m_cursor.to_end();
+    }
+    
+    void up()
+    {
+        m_cursor.to_parent();
+    }
 };
 
 

Modified: sandbox/SOC/2006/tree/trunk/boost/tree/cursor_facade.hpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/boost/tree/cursor_facade.hpp	(original)
+++ sandbox/SOC/2006/tree/trunk/boost/tree/cursor_facade.hpp	2008-09-17 18:05:38 EDT (Wed, 17 Sep 2008)
@@ -32,53 +32,53 @@
 class cursor_core_access {
  public:
  
- 	friend class iterator_core_access;
- 	
-  	template <class Facade>
-	static bool empty_(Facade const& f)
-	{
-		return f.empty_();
-	}
-	
- 	template <class Facade>
-	static typename Facade::size_type size_(Facade const& f)
-	{
-		return f.size_();
-	}
-	
-	template <class Facade>
-	static typename Facade::size_type max_size_(Facade const& f)
-	{
-		return f.max_size_();
-	}
-
-	template <class Facade>
-	static typename Facade::size_type par(Facade const& f)
-	{
-		return f.par();
-	}
-		
-	template <class Facade>
-	static void left(Facade& f)
-	{
-		f.left();
-	}
-	
-	template <class Facade>
-	static void right(Facade& f)
-	{
-		f.right();
-	}
-	
-	//only if ascending
-	template <class Facade>
-	static void up(Facade& f)
-	{
-		f.up();
-	}
+     friend class iterator_core_access;
+     
+      template <class Facade>
+    static bool empty_(Facade const& f)
+    {
+        return f.empty_();
+    }
+    
+     template <class Facade>
+    static typename Facade::size_type size_(Facade const& f)
+    {
+        return f.size_();
+    }
+    
+    template <class Facade>
+    static typename Facade::size_type max_size_(Facade const& f)
+    {
+        return f.max_size_();
+    }
+
+    template <class Facade>
+    static typename Facade::size_type par(Facade const& f)
+    {
+        return f.par();
+    }
+        
+    template <class Facade>
+    static void left(Facade& f)
+    {
+        f.left();
+    }
+    
+    template <class Facade>
+    static void right(Facade& f)
+    {
+        f.right();
+    }
+    
+    //only if ascending
+    template <class Facade>
+    static void up(Facade& f)
+    {
+        f.up();
+    }
 
 private:
-	cursor_core_access();
+    cursor_core_access();
 };
 
 template <
@@ -88,109 +88,109 @@
   , class VerticalCategoryOrTraversal
   , class Reference   = Value&
   , class Difference  = std::ptrdiff_t
-  , class Size		  = std::size_t
+  , class Size          = std::size_t
 >
 class cursor_facade 
  : public iterator_facade<Derived, Value, HorizontalCategoryOrTraversal, 
-						  Reference, Difference> {
+                          Reference, Difference> {
  private:
-	// Curiously Recurring Template interface.
+    // Curiously Recurring Template interface.
 
-	Derived& derived()
-	{
-	    return *static_cast<Derived*>(this);
-	}
-	
-	Derived const& derived() const
-	{
-	    return *static_cast<Derived const*>(this);
-	}
+    Derived& derived()
+    {
+        return *static_cast<Derived*>(this);
+    }
+    
+    Derived const& derived() const
+    {
+        return *static_cast<Derived const*>(this);
+    }
 
-	typedef typename cursor_facade::iterator_facade_ iterator_facade_;
+    typedef typename cursor_facade::iterator_facade_ iterator_facade_;
 
  protected:
- 	// For use by derived classes
-	typedef cursor_facade<Derived, Value, HorizontalCategoryOrTraversal,
-						  VerticalCategoryOrTraversal, Reference, Difference> 
-			cursor_facade_;
+     // For use by derived classes
+    typedef cursor_facade<Derived, Value, HorizontalCategoryOrTraversal,
+                          VerticalCategoryOrTraversal, Reference, Difference> 
+            cursor_facade_;
  public:
-	typedef typename iterator_facade_::value_type value_type;
-	typedef Reference reference;
-	typedef Difference difference_type;
-	typedef typename iterator_facade_::pointer pointer;
-	typedef typename iterator_facade_::iterator_category iterator_category;
-
-	typedef Size size_type;
-
-	typedef bidirectional_traversal_tag cursor_category; //TODO
-	typedef typename 
-		iterator_category_to_traversal<iterator_category>::type
-		horizontal_traversal; 
-	typedef typename 
-		iterator_category_to_traversal<VerticalCategoryOrTraversal>::type
-		vertical_traversal; 
-
-	bool const empty() const
-	{
-		return cursor_core_access::empty_(this->derived());
-	}
-	
-	size_type const size() const
-	{
-		return cursor_core_access::size_(this->derived());
-	}
-	
-	size_type const max_size() const
-	{
-		return cursor_core_access::max_size_(this->derived());
-	}
-
-	size_type const parity() const
-	{
-		return cursor_core_access::par(this->derived());
-	}
-
- 	Derived& to_begin()
- 	{
-		cursor_core_access::left(this->derived());
-		return this->derived();
- 	}
- 				 
- 	Derived begin()
- 	{
- 		Derived tmp(this->derived());
- 		return tmp.to_begin();
- 	}
-
- 	Derived& to_end()
- 	{
-		cursor_core_access::right(this->derived());
-		return this->derived();
- 	}
- 	
- 	Derived end()
- 	{
- 		Derived tmp(this->derived());
- 		return tmp.to_end();
-  	}
- 	
- 	Derived& to_parent()
- 	{
- 		cursor_core_access::up(this->derived());
- 		return this->derived();
- 	}
- 	
- 	Derived parent()
- 	{
- 		Derived tmp(this->derived());
- 		return tmp.to_parent();
- 	}
+    typedef typename iterator_facade_::value_type value_type;
+    typedef Reference reference;
+    typedef Difference difference_type;
+    typedef typename iterator_facade_::pointer pointer;
+    typedef typename iterator_facade_::iterator_category iterator_category;
+
+    typedef Size size_type;
+
+    typedef bidirectional_traversal_tag cursor_category; //TODO
+    typedef typename 
+        iterator_category_to_traversal<iterator_category>::type
+        horizontal_traversal; 
+    typedef typename 
+        iterator_category_to_traversal<VerticalCategoryOrTraversal>::type
+        vertical_traversal; 
+
+    bool const empty() const
+    {
+        return cursor_core_access::empty_(this->derived());
+    }
+    
+    size_type const size() const
+    {
+        return cursor_core_access::size_(this->derived());
+    }
+    
+    size_type const max_size() const
+    {
+        return cursor_core_access::max_size_(this->derived());
+    }
+
+    size_type const parity() const
+    {
+        return cursor_core_access::par(this->derived());
+    }
+
+     Derived& to_begin()
+     {
+        cursor_core_access::left(this->derived());
+        return this->derived();
+     }
+                  
+     Derived begin()
+     {
+         Derived tmp(this->derived());
+         return tmp.to_begin();
+     }
+
+     Derived& to_end()
+     {
+        cursor_core_access::right(this->derived());
+        return this->derived();
+     }
+     
+     Derived end()
+     {
+         Derived tmp(this->derived());
+         return tmp.to_end();
+      }
+     
+     Derived& to_parent()
+     {
+         cursor_core_access::up(this->derived());
+         return this->derived();
+     }
+     
+     Derived parent()
+     {
+         Derived tmp(this->derived());
+         return tmp.to_parent();
+     }
 };
 
 //TODO: Put somewhere else?
 template <class Value>
 struct metadata {
-	struct type {};
+    struct type {};
 };
 
 } // namespace tree

Modified: sandbox/SOC/2006/tree/trunk/boost/tree/forest_tree.hpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/boost/tree/forest_tree.hpp	(original)
+++ sandbox/SOC/2006/tree/trunk/boost/tree/forest_tree.hpp	2008-09-17 18:05:38 EDT (Wed, 17 Sep 2008)
@@ -35,78 +35,78 @@
 */
 template <class T, class Hierarchy = binary_tree<T> >
 class forest_tree {
-	typedef forest_tree<T, Hierarchy> self_type;
+    typedef forest_tree<T, Hierarchy> self_type;
  public:
-	typedef T value_type;
-	typedef Hierarchy hierarchy_type;
+    typedef T value_type;
+    typedef Hierarchy hierarchy_type;
 
-	typedef typename hierarchy_type::cursor base_cursor;
-	typedef typename hierarchy_type::const_cursor base_const_cursor;
-	
-	typedef forest_cursor<base_cursor> cursor;
-	typedef forest_cursor<base_const_cursor> const_cursor;
-	
-	typedef typename cursor_pointer<cursor>::type pointer;
-	typedef typename cursor_reference<cursor>::type reference;
-	typedef typename cursor_size<cursor>::type size_type;
-	typedef typename cursor_difference<cursor>::type difference_type;
-
-//	forest_tree()
-//	{
-//		h.insert(h.root(), );
-//	}
-	
-	explicit forest_tree(Hierarchy const& hier = Hierarchy()) : h(hier)
-	{ }
-	
-	bool empty()
-	{
-		return h.empty();
-	}
-	
-	size_type size() const
-	{
-		return h.size();
-	}
-	
-	/**
-	 * Returns a read/write ("mutable") cursor to the %binary_tree's root.
-	 */ 	
-	cursor root()
-	{
-		return cursor(h.root());
-	}
-
-	/**
-	 * Returns a read-only const_cursor to the %binary_tree's root.
-	 */ 	
-	const_cursor root() const
-	{
-		return croot();
-	}
-	
-	/**
-	 * Returns a read-only const_cursor to the %binary_tree's root.
-	 */ 	
-	const_cursor croot() const
-	{
-		return const_cursor(h.croot());
-	}
-
-	cursor insert(cursor pos, value_type const& val)
-	{
-		// TODO: Could we remove the root-checking part if root.parent() 
-		// returned root? Or don't we even want root?
-		base_cursor bc = base_cursor(pos);
-		if (bc != h.root())
-			bc = bc.parent();
-		//if (bc.parity())
-		return cursor(h.insert(bc, val));
-	}
-	
+    typedef typename hierarchy_type::cursor base_cursor;
+    typedef typename hierarchy_type::const_cursor base_const_cursor;
+    
+    typedef forest_cursor<base_cursor> cursor;
+    typedef forest_cursor<base_const_cursor> const_cursor;
+    
+    typedef typename cursor_pointer<cursor>::type pointer;
+    typedef typename cursor_reference<cursor>::type reference;
+    typedef typename cursor_size<cursor>::type size_type;
+    typedef typename cursor_difference<cursor>::type difference_type;
+
+//    forest_tree()
+//    {
+//        h.insert(h.root(), );
+//    }
+    
+    explicit forest_tree(Hierarchy const& hier = Hierarchy()) : h(hier)
+    { }
+    
+    bool empty()
+    {
+        return h.empty();
+    }
+    
+    size_type size() const
+    {
+        return h.size();
+    }
+    
+    /**
+     * Returns a read/write ("mutable") cursor to the %binary_tree's root.
+     */     
+    cursor root()
+    {
+        return cursor(h.root());
+    }
+
+    /**
+     * Returns a read-only const_cursor to the %binary_tree's root.
+     */     
+    const_cursor root() const
+    {
+        return croot();
+    }
+    
+    /**
+     * Returns a read-only const_cursor to the %binary_tree's root.
+     */     
+    const_cursor croot() const
+    {
+        return const_cursor(h.croot());
+    }
+
+    cursor insert(cursor pos, value_type const& val)
+    {
+        // TODO: Could we remove the root-checking part if root.parent() 
+        // returned root? Or don't we even want root?
+        base_cursor bc = base_cursor(pos);
+        if (bc != h.root())
+            bc = bc.parent();
+        //if (bc.parity())
+        return cursor(h.insert(bc, val));
+    }
+    
  protected:
-	hierarchy_type h;
- 	
+    hierarchy_type h;
+     
 };
 
 

Modified: sandbox/SOC/2006/tree/trunk/boost/tree/graph.hpp
==============================================================================
--- sandbox/SOC/2006/tree/trunk/boost/tree/graph.hpp	(original)
+++ sandbox/SOC/2006/tree/trunk/boost/tree/graph.hpp	2008-09-17 18:05:38 EDT (Wed, 17 Sep 2008)
@@ -35,15 +35,15 @@
 template <class Cursor>
 class out_edge_iterator
  : public iterator_facade<out_edge_iterator<Cursor>
- 						, std::pair<Cursor, Cursor>
- 						, typename cursor_horizontal_traversal<Cursor>::type
- 						/*, Reference, Difference*/> {
+                         , std::pair<Cursor, Cursor>
+                         , typename cursor_horizontal_traversal<Cursor>::type
+                         /*, Reference, Difference*/> {
 
-	struct enabler {};
+    struct enabler {};
 public:
-	out_edge_iterator() : m_edge() {}
-	
-	explicit out_edge_iterator(Cursor u, Cursor v) : m_edge(u, v) {}
+    out_edge_iterator() : m_edge() {}
+    
+    explicit out_edge_iterator(Cursor u, Cursor v) : m_edge(u, v) {}
 
     template <class OtherCursor>
     out_edge_iterator(
@@ -55,9 +55,9 @@
     )
       : m_edge(other.m_edge) {}
 
-	
+    
 private:
-	friend class boost::iterator_core_access;
+    friend class boost::iterator_core_access;
 
     template <class OtherCursor>
     bool equal(out_edge_iterator<OtherCursor> const& other) const
@@ -67,27 +67,27 @@
 
     void increment()
     {
-    	// We also need to account for the cursor's end()!
-    	if (m_edge.second == m_edge.first.end()) { 
-    		m_edge.second = m_edge.first;
-    		return;
-    	}
-    	++m_edge.second; 
+        // We also need to account for the cursor's end()!
+        if (m_edge.second == m_edge.first.end()) { 
+            m_edge.second = m_edge.first;
+            return;
+        }
+        ++m_edge.second; 
     }
 
     void decrement()
     { 
-       	if (m_edge.second == m_edge.first) { 
-    		m_edge.second = m_edge.first.end();
-    		return;
-    	}
-    	--m_edge.second;
+           if (m_edge.second == m_edge.first) { 
+            m_edge.second = m_edge.first.end();
+            return;
+        }
+        --m_edge.second;
     }
 
     std::pair<Cursor, Cursor>& dereference() const
     { return const_cast<std::pair<Cursor, Cursor>&>(m_edge); }
 
-	std::pair<Cursor, Cursor> m_edge; 
+    std::pair<Cursor, Cursor> m_edge; 
 };
 
 } // namespace tree
@@ -101,22 +101,22 @@
 struct graph_traits< binary_tree<Tp, Alloc> > {
     typedef typename binary_tree<Tp, Alloc>::cursor vertex_descriptor;
     typedef std::pair<vertex_descriptor
-    				, vertex_descriptor> edge_descriptor; // Might be tunable...
+                    , vertex_descriptor> edge_descriptor; // Might be tunable...
 
-	typedef boost::tree::out_edge_iterator<vertex_descriptor> out_edge_iterator;
+    typedef boost::tree::out_edge_iterator<vertex_descriptor> out_edge_iterator;
 
     typedef directed_tag directed_category;
     typedef disallow_parallel_edge_tag edge_parallel_category;
-	typedef incidence_graph_tag traversal_category;
+    typedef incidence_graph_tag traversal_category;
     typedef 
-    	typename cursor_size<vertex_descriptor>::type 
-    	vertices_size_type;
+        typename cursor_size<vertex_descriptor>::type 
+        vertices_size_type;
     typedef
-    	typename cursor_size<vertex_descriptor>::type
-    	edges_size_type;
+        typename cursor_size<vertex_descriptor>::type
+        edges_size_type;
     typedef
-    	typename cursor_size<vertex_descriptor>::type
-    	degree_size_type;
+        typename cursor_size<vertex_descriptor>::type
+        degree_size_type;
 };
 
 //template <class Tp, class Alloc>
@@ -146,8 +146,8 @@
     const binary_tree<Tp, Alloc>& g)
 {
     typedef
-    	typename graph_traits< binary_tree<Tp, Alloc> >::out_edge_iterator
-    	Iter;
+        typename graph_traits< binary_tree<Tp, Alloc> >::out_edge_iterator
+        Iter;
     return std::make_pair(Iter(u, u.begin()), Iter(u, u));
 }
 
@@ -161,15 +161,15 @@
 }
 
 template <
-	class Cursor, 
-	class Op //= typename identity<typename boost::tree::cursor_value<Cursor>::type>
+    class Cursor, 
+    class Op //= typename identity<typename boost::tree::cursor_value<Cursor>::type>
 >
 struct extract_property_map;
 
 template <class Cursor, class Op>
 class extract_property_map
 : public boost::put_get_helper<typename Op::result_type&
-							 , extract_property_map<Cursor, Op> >
+                             , extract_property_map<Cursor, Op> >
 {
 public:
     typedef Cursor key_type;
@@ -177,11 +177,11 @@
     typedef value_type& reference;
     typedef boost::lvalue_property_map_tag category;
 
-	extract_property_map(Op op = Op()) : m_op(op) {}
+    extract_property_map(Op op = Op()) : m_op(op) {}
 
     inline reference operator[](key_type v) const
     {
-    	return m_op(*v.to_begin());
+        return m_op(*v.to_begin());
     }
     
 private:
@@ -191,7 +191,7 @@
 template <class Tree>
 bool empty_cursor(typename Tree::cursor u, Tree)
 {
-	return u.empty();
+    return u.empty();
 }
 
 } // namespace boost