recursive call returning a functor

Hi guys,

Is there a way to return a functor from a recursive call that takes
different paths? Let's say that I have a tree structure like:

   root
    |
   first child ----> nextSibling ----> nextSibling ----> nextSibling
---->0
         | |
| |
        0 |
0 0
                           firstChild -> 0
                               |
                              0

Now, I would like to create a function that executes a functor on leaf
objects. Is this possible???
In code, let's say we have a tree class:

template <class Object>
class Tree {

    struct TreeNode {

        TreeNode() : obj_(), firstChild_(NULL), nextSibling_(NULL),
parent_(NULL), depth_() {}

        TreeNode(Object obj) : obj_(obj), firstChild_(NULL),
        nextSibling_(NULL), parent_(NULL), depth_() {}

        Object obj_;
        size_t depth_;
        TreeNode* firstChild_;
        TreeNode* nextSibling_;
        TreeNode* parent_;
    };

    TreeNode* root_; //!< The root of the tree
    TreeNode* current_; //!< Helper pointer for searches
    size_t size_; //!< Number of nodes in the tree
    size_t height_; //!< Tree height

public:

    typedef Object ValueType;
    typedef Object& ReferenceType;
    typedef Object* IteratorType;

    //! Default constructor
    Tree() : size_() { root_ = current_ = NULL; }

// more constructors, assignment operator and destructor...
// functions to return size and height...

    template <class Functor>
    Functor LeafExecute(Functor fn) {
        //set current to root to start execution
        current_ = root_;
        //uses the private function FindObject
        return LeafExecute(current_, fn);
    }

private:

    template <class Functor>
    Functor LeafExecute(TreeNode* ptr, Functor fn) {

        //recursively executes the rest of the tree
        if (ptr->nextSibling_ != NULL)
            LeafExecute(ptr->nextSibling_,fn);
        if(ptr->firstChild_ != NULL)
            LeafExecute(ptr->firstChild_,fn);
        else if (ptr->firstChild_ == NULL) {
            // execute functor
            cout<<"executing functor at depth "<<ptr->depth_<<endl;
            fn(ptr->obj_);
            return fn;
        }
    }
};

I'm following the same behavior as the for_each algorithm in the
standard library:

  template<typename _InputIterator, typename _Function>
    _Function
    for_each(_InputIterator __first, _InputIterator __last, _Function
__f)
    {
      // concept requirements
 
__glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
      __glibcxx_requires_valid_range(__first, __last);
      for (; __first != __last; ++__first)
    __f(*__first);
      return __f;
    }

except that it doesn't work as I expected and I don't know why. Maybe
because I'm calling the recursion on the siblings? Note that the
functor is passed by value to the function and returned by value (of
course)
I appreciate any feedback.

aa