#include <iostream>

 class VirtualBase {
      public:
        VirtualBase() { std::cout << "init from VirtualBase" << std::endl; }
        virtual int doWork() {
        	std::cout << "doing work from c++" << std::endl;
        	return 0;
        }
        virtual int processWorker() = 0;
    };



#include "rice/Director.hpp"
  using namespace Rice;

    class VirtualBaseProxy : public VirtualBase, public Rice::Director {
      public:
        VirtualBaseProxy(Object self) : Rice::Director(self) { }

        virtual int doWork() {
        std::cout << "salut!!" << std::endl;
          if(callIsFromRuby("do_work")) {
          	std::cout << "hello!!" << std::endl;
            return VirtualBase::doWork();
          } else {
            return from_ruby<int>( getSelf().call("do_work") );
          }
        }

        virtual int processWorker() {
          if(callIsFromRuby("process_worker")) {
            raisePureVirtual();
          } else {
            return from_ruby<int>( getSelf().call("process_worker") );
          }
        }
    };

#include "rice/Constructor.hpp"

extern "C"
  void Init_virtual() {
    // See Caveat below
    define_class<VirtualBase>("__VirtualBase__");
 //	.define_method("do_work", &VirtualBase::doWork);

    define_class<VirtualBaseProxy, VirtualBase>("VirtualBase")
     .define_constructor(Constructor<VirtualBaseProxy, Object>())
     .define_method("do_work", &VirtualBaseProxy::doWork)
     .define_method("process_worker", &VirtualBaseProxy::processWorker);
  }