Looking for example usages of boost::iterator_facade

I have an existing code containing some facade_iterators, and I would like to interface them from (C)Python. Schematically, my idea is, from Python:

1. Initialize the iterator
2. Call successively dereference() and increment()

The few code examples I've seen only show std::for_each and std::copy, like here from the official doc https://www.boost.org/doc/libs/1_65_0/libs/iterator/example/node_iterator2.cpp . But I don't want to iterate over everything at once.

I've tried to turn the functions increment() and dereference() public, and then call them directly: it works. I guess this should be achieved using boost::iterator_core_access, but I cannot find how. Here is the full code:

// File test.h
#include <iostream>
#include <boost/iterator/iterator_facade.hpp>
struct node_base {
node_base() : m_next(0) {}
virtual ~node_base() { delete m_next; }
node_base* next() const { return m_next; }
virtual void print(std::ostream& s) const = 0;
virtual void double_me() = 0;
void append(node_base* p) {
if (m_next) m_next->append(p);
else m_next = p;
}
private:
node_base* m_next;
};
template <class T>
struct node : node_base {
node(T x) : m_value(x) {}
void print(std::ostream& s) const { s << this->m_value; }
void double_me() { m_value += m_value; }
private:
T m_value;
};
inline std::ostream& operator<<(std::ostream& s, node_base const& n) {
n.print(s);
return s;
}
template <class Value>
class node_iter : public boost::iterator_facade<
node_iter<Value>
, Value
, boost::forward_traversal_tag> {
public:
node_iter() : m_node(0) {}
explicit node_iter(Value* p) : m_node(p) {}
template <class OtherValue>
node_iter(node_iter<OtherValue> const& other) : m_node(other.m_node) {}
//private: //private should start here
friend class boost::iterator_core_access;
template <class> friend class node_iter;
template <class OtherValue>
bool equal(node_iter<OtherValue> const& other) const {
return this->m_node == other.m_node;
}
void increment() { m_node = m_node->next(); }
Value& dereference() const { return *m_node; }
private: //if it's moved here, the example works
Value* m_node;
};
typedef node_iter<node_base> node_iterator;
typedef node_iter<node_base const> node_const_iterator;
// File test.cpp
#include "test.h"
#include <iostream>
#include <memory>
int main() {
std::unique_ptr<node<int> > nodes(new node<int>(42));
nodes->append(new node<int>(13));
auto nit = new node_iterator(nodes.get());
std::cout << nit->dereference() << std::endl;
nit->increment();
std::cout << nit->dereference() << std::endl;
return 0;
}
// How to do the same with private increment() and dereference()?

EDIT: I tried replacing the three last lines in main() by

  std::cout << boost::iterator_core_access::dereference(*nit) << std::endl;
boost::iterator_core_access::increment(*nit);
std::cout << boost::iterator_core_access::dereference(*nit) << std::endl;

But I get an error telling me that dereference() and increment() are private. However when I look in the source (boost/iterator/iterator_facade.hpp) the functions seem to belong to a public block. So I'm confused.

You should be using ++ and *. You probably shouldn't be dynamically allocating node_iterator.

int main() {
std::unique_ptr<node<int> > nodes = std::make_unique(42);
nodes->append(std::make_unique(13));
node_iterator nit(nodes.get());
std::cout << *nit << std::endl;
++nit;
std::cout << *nit << std::endl;
return 0;
}