swig/Lib/perl5/director.swg

/* -----------------------------------------------------------------------------
 * director.swg
 *
 * This file contains support for director classes that proxy
 * method calls from C++ to Python extensions.
 * ----------------------------------------------------------------------------- */

#ifndef SWIG_DIRECTOR_PERL_HEADER_
#define SWIG_DIRECTOR_PERL_HEADER_

#ifdef __cplusplus

#include <string>
#include <iostream>
#include <exception>
#include <vector>
#include <map>


/*
  Use -DSWIG_PYTHON_DIRECTOR_NO_VTABLE if you don't want to generate a 'virtual
  table', and avoid multiple GetAttr calls to retrieve the python
  methods.
*/

#ifndef SWIG_PERL_DIRECTOR_NO_VTABLE
#ifndef SWIG_PERL_DIRECTOR_VTABLE
#define SWIG_PERL_DIRECTOR_VTABLE
#endif
#endif



/*
  Use -DSWIG_DIRECTOR_NO_UEH if you prefer to avoid the use of the
  Undefined Exception Handler provided by swig.
*/
#ifndef SWIG_DIRECTOR_NO_UEH
#ifndef SWIG_DIRECTOR_UEH
#define SWIG_DIRECTOR_UEH
#endif
#endif


/*
  Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
  'Swig' namespace. This could be useful for multi-modules projects.
*/
#ifdef SWIG_DIRECTOR_STATIC
/* Force anonymous (static) namespace */
#define Swig
#endif


/*
  Use -DSWIG_DIRECTOR_NORTTI if you prefer to avoid the use of the
  native C++ RTTI and dynamic_cast<>. But be aware that directors
  could stop working when using this option.
*/
#ifdef SWIG_DIRECTOR_NORTTI
/*
   When we don't use the native C++ RTTI, we implement a minimal one
   only for Directors.
*/
# ifndef SWIG_DIRECTOR_RTDIR
# define SWIG_DIRECTOR_RTDIR
#include <map>

namespace Swig {
  class Director;
  SWIGINTERN std::map<void*,Director*>& get_rtdir_map() {
    static std::map<void*,Director*> rtdir_map;
    return rtdir_map;
  }

  SWIGINTERNINLINE void set_rtdir(void *vptr, Director *rtdir) {
    get_rtdir_map()[vptr] = rtdir;
  }

  SWIGINTERNINLINE Director *get_rtdir(void *vptr) {
    std::map<void*,Director*>::const_iterator pos = get_rtdir_map().find(vptr);
    Director *rtdir = (pos != get_rtdir_map().end()) ? pos->second : 0;
    return rtdir;
  }
}
# endif /* SWIG_DIRECTOR_RTDIR */

# define SWIG_DIRECTOR_CAST(ARG) Swig::get_rtdir(static_cast<void*>(ARG))
# define SWIG_DIRECTOR_RGTR(ARG1, ARG2) Swig::set_rtdir(static_cast<void*>(ARG1), ARG2)

#else

# define SWIG_DIRECTOR_CAST(ARG) dynamic_cast<Swig::Director *>(ARG)
# define SWIG_DIRECTOR_RGTR(ARG1, ARG2)

#endif /* SWIG_DIRECTOR_NORTTI */

extern "C" {
  struct swig_type_info;
}

namespace Swig {

  /* memory handler */
  struct GCItem
  {
    virtual ~GCItem() {}

    virtual int get_own() const
    {
      return 0;
    }
  };

  struct GCItem_var
  {
    GCItem_var(GCItem *item = 0) : _item(item)
    {
    }

    GCItem_var& operator=(GCItem *item)
    {
      GCItem *tmp = _item;
      _item = item;
      delete tmp;
      return *this;
    }

    ~GCItem_var()
    {
      delete _item;
    }

    GCItem * operator->() const
    {
      return _item;
    }

  private:
    GCItem *_item;
  };

  struct GCItem_Object : GCItem
  {
    GCItem_Object(int own) : _own(own)
    {
    }

    virtual ~GCItem_Object()
    {
    }

    int get_own() const
    {
      return _own;
    }

  private:
    int _own;
  };

  template <typename Type>
  struct GCItem_T : GCItem
  {
    GCItem_T(Type *ptr) : _ptr(ptr)
    {
    }

    virtual ~GCItem_T()
    {
      delete _ptr;
    }

  private:
    Type *_ptr;
  };

  template <typename Type>
  struct GCArray_T : GCItem
  {
    GCArray_T(Type *ptr) : _ptr(ptr)
    {
    }

    virtual ~GCArray_T()
    {
      delete[] _ptr;
    }

  private:
    Type *_ptr;
  };

  /* base class for director exceptions */
  class DirectorException {
  public:
    virtual const char *getMessage() const = 0;
    virtual SV *getNative() const = 0;
  };
  /* exceptions emitted by Perl */
  class DirectorMethodException : public Swig::DirectorException {
  protected:
    SV *err;
  public:
    DirectorMethodException(SV *sv = sv_mortalcopy(ERRSV))
      : err(sv)
    {
      SvREFCNT_inc(err);
    }
    ~DirectorMethodException()
    {
      SvREFCNT_dec(err);
    }
    const char *getMessage() const
    {
      return SvPV_nolen(err);
    }
    SV *getNative() const
    {
      return sv_2mortal(newSVsv(err));
    }
    static void raise(SV *sv)
    {
      throw DirectorMethodException(sv);
    }
  };
  /* exceptions emitted by wrap code */
  class DirectorWrapException : public Swig::DirectorException {
  protected:
    std::string msg;
    DirectorWrapException(const char *str)
      : msg(str)
    {
    }
  public:
    virtual const char *getMessage() const
    {
      return msg.c_str();
    }
    virtual SV *getNative() const {
      return sv_2mortal(newSVpvn(msg.data(), msg.size()));
    }
  };
  class DirectorTypeMismatchException : public Swig::DirectorWrapException {
  public:
    DirectorTypeMismatchException(const char *str)
      : DirectorWrapException(str)
    {
    }
    static void raise(const char *type, const char *msg)
    {
      std::string err = std::string(type);
      err += ": ";
      err += msg;
      throw DirectorTypeMismatchException(err.c_str());
    }
  };
  class DirectorPureVirtualException : public Swig::DirectorWrapException {
  public:
    DirectorPureVirtualException(const char *name)
      : DirectorWrapException("SWIG director pure virtual method called: ")
    {
      msg += name;
    }
    static void raise(const char *name)
    {
      throw DirectorPureVirtualException(name);
    }
  };
//  /* unknown exception handler  */
//  class UnknownExceptionHandler
//  {
//#ifdef SWIG_DIRECTOR_UEH
//    static void handler()  {
//      try {
//        throw;
//      } catch (DirectorException& e) {
//        std::cerr << "SWIG Director exception caught:" << std::endl
//                  << e.getMessage() << std::endl;
//      } catch (std::exception& e) {
//        std::cerr << "std::exception caught: "<< e.what() << std::endl;
//      } catch (...) {
//        std::cerr << "Unknown exception caught." << std::endl;
//      }
//
//      //std::cerr << std::endl
//      //          << "Python interpreter traceback:" << std::endl;
//      //PyErr_Print();
//      //std::cerr << std::endl;
//
//      std::cerr << "This exception was caught by the SWIG unexpected exception handler." << std::endl
//                << "Try using %feature(\"director:except\") to avoid reaching this point." << std::endl
//                << std::endl
//                << "Exception is being re-thrown, program will likely abort/terminate." << std::endl;
//      throw;
//    }
//
//  public:
//
//    std::unexpected_handler old;
//    UnknownExceptionHandler(std::unexpected_handler nh = handler)
//    {
//      old = std::set_unexpected(nh);
//    }
//
//    ~UnknownExceptionHandler()
//    {
//      std::set_unexpected(old);
//    }
//#endif
//  };

#if defined(SWIG_PYTHON_THREADS)
/*  __THREAD__ is the old macro to activate some thread support */
# if !defined(__THREAD__)
#   define __THREAD__ 1
# endif
#endif

#ifdef __THREAD__
# include "pythread.h"
  class Guard
  {
    PyThread_type_lock & mutex_;

  public:
    Guard(PyThread_type_lock & mutex) : mutex_(mutex)
    {
      PyThread_acquire_lock(mutex_, WAIT_LOCK);
    }

    ~Guard()
    {
      PyThread_release_lock(mutex_);
    }
  };
# define SWIG_GUARD(mutex) Guard _guard(mutex)
#else
# define SWIG_GUARD(mutex)
#endif

  /* director base class */
  class Director {
  private:
    /* pointer to the wrapped perl object */
    SV *swig_self;
    /* class of wrapped perl object */
    std::string swig_class;
    /* flag indicating whether the object is owned by perl or c++ */
    mutable bool swig_disown_flag;

    /* decrement the reference count of the wrapped perl object */
    void swig_decref() const {
      if (swig_disown_flag) {
        SvREFCNT_dec(swig_self);
      }
    }

  public:
    /* wrap a python object, optionally taking ownership */
    Director(SV *pkg) : swig_disown_flag(false) {
      STRLEN len;
      char *str = SvPV(pkg, len);
      swig_class = std::string(str, len);
      swig_self = newRV_inc((SV *)newHV());
      swig_incref();
    }


    /* discard our reference at destruction */
    virtual ~Director() {
      swig_decref();
    }


    /* return a pointer to the wrapped python object */
    SV *swig_get_self() const {
      return swig_self;
    }

    const char *swig_get_class() const {
      return swig_class.c_str();
    }

    /* acquire ownership of the wrapped python object (the sense of "disown"
     * is from python) */
    void swig_disown() const {
      if (!swig_disown_flag) {
        swig_disown_flag=true;
        swig_incref();
      }
    }

    /* increase the reference count of the wrapped python object */
    void swig_incref() const {
      if (swig_disown_flag) {
        SvREFCNT_inc(swig_self);
      }
    }

    /* methods to implement pseudo protected director members */
    virtual bool swig_get_inner(const char* /* swig_protected_method_name */) const {
      return true;
    }

    virtual void swig_set_inner(const char* /* swig_protected_method_name */, bool /* swig_val */) const {
    }

  /* ownership management */
  private:
    typedef std::map<void*, GCItem_var> swig_ownership_map;
    mutable swig_ownership_map swig_owner;
#ifdef __THREAD__
    static PyThread_type_lock swig_mutex_own;
#endif

  public:
    template <typename Type>
    void swig_acquire_ownership_array(Type *vptr)  const
    {
      if (vptr) {
        SWIG_GUARD(swig_mutex_own);
        swig_owner[vptr] = new GCArray_T<Type>(vptr);
      }
    }

    template <typename Type>
    void swig_acquire_ownership(Type *vptr)  const
    {
      if (vptr) {
        SWIG_GUARD(swig_mutex_own);
        swig_owner[vptr] = new GCItem_T<Type>(vptr);
      }
    }

    void swig_acquire_ownership_obj(void *vptr, int own) const
    {
      if (vptr && own) {
        SWIG_GUARD(swig_mutex_own);
        swig_owner[vptr] = new GCItem_Object(own);
      }
    }

    int swig_release_ownership(void *vptr) const
    {
      int own = 0;
      if (vptr) {
        SWIG_GUARD(swig_mutex_own);
        swig_ownership_map::iterator iter = swig_owner.find(vptr);
        if (iter != swig_owner.end()) {
          own = iter->second->get_own();
          swig_owner.erase(iter);
        }
      }
      return own;
    }

    //template <typename Type>
    //static PyObject* swig_pyobj_disown(PyObject *pyobj, PyObject *SWIGUNUSEDPARM(args))
    //{
    //  SwigPyObject *sobj = (SwigPyObject *)pyobj;
    //  sobj->own = 0;
    //  Director *d = SWIG_DIRECTOR_CAST(reinterpret_cast<Type *>(sobj->ptr));
    //  if (d)
    //    d->swig_disown();
    //  return PyWeakref_NewProxy(pyobj, NULL);
    //}

  };

#ifdef __THREAD__
  PyThread_type_lock Director::swig_mutex_own = PyThread_allocate_lock();
#endif
}

#endif /* __cplusplus */


#endif