#include "boost/variant.hpp"
#include <iostream>

class Waterfall {

protected:
  class Processor {

  public:
    // forward declarations
    class SparseRow;
    class DenseRow;
    typedef SparseRow* sparse_row_ptr;
    typedef DenseRow* dense_row_ptr;
    typedef boost::variant< sparse_row_ptr,dense_row_ptr > row_ptr;

  protected:
    row_ptr row;

  public:
    Processor() : row(new DenseRow()) { };

    class SparseRow {
    public:
      size_t size() const { return 1; };
    };

    class DenseRow {
    public:
      size_t size() const { return 42; };
    };

    int step() {
      // get row size with boost::variant
      class __row_size : public boost::static_visitor<size_t> {
      public:
        size_t operator() (const sparse_row_ptr& r) {
          return r->size();
        };
        size_t operator() (const dense_row_ptr& r) {
          return r->size();
        };
      }; // class __row_size
      class _row_size {
      public:
        size_t operator() (row_ptr& r) {
          return boost::apply_visitor(__row_size(), r);
        };
      } row_size; 

      return row_size(row);
    }; // int step()

  }; // class Processor

  Processor p;

public:
  
  Waterfall() : p() { };

  int run() {
    return p.step();
  };
}; // class Waterfall


int main()
{
  Waterfall wf;
  int result = wf.run();
  std::cout << result << std::endl; // output: 42
}