/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 4.0.2
 *
 * This file is not intended to be easily readable and contains a number of
 * coding conventions designed to improve portability and efficiency. Do not make
 * changes to this file unless you know what you are doing--modify the SWIG
 * interface file instead.
 * ----------------------------------------------------------------------------- */


#ifndef SWIGCSHARP
#define SWIGCSHARP
#endif

#define SWIG_DIRECTORS


#ifdef __cplusplus
/* SwigValueWrapper is described in swig.swg */
template<typename T> class SwigValueWrapper {
  struct SwigMovePointer {
    T *ptr;
    SwigMovePointer(T *p) : ptr(p) { }
    ~SwigMovePointer() { delete ptr; }
    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  } pointer;
  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
  SwigValueWrapper() : pointer(0) { }
  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  operator T&() const { return *pointer.ptr; }
  T *operator&() { return pointer.ptr; }
};

template <typename T> T SwigValueInit() {
  return T();
}
#endif

/* -----------------------------------------------------------------------------
 *  This section contains generic SWIG labels for method/variable
 *  declarations/attributes, and other compiler dependent labels.
 * ----------------------------------------------------------------------------- */

/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
#  define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
#  define SWIGTEMPLATEDISAMBIGUATOR template
# else
#  define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif

/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
#   define SWIGINLINE inline
# else
#   define SWIGINLINE
# endif
#endif

/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#     define SWIGUNUSED __attribute__ ((__unused__))
#   else
#     define SWIGUNUSED
#   endif
# elif defined(__ICC)
#   define SWIGUNUSED __attribute__ ((__unused__))
# else
#   define SWIGUNUSED
# endif
#endif

#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif
#endif

#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
#   define SWIGUNUSEDPARM(p)
# else
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif

/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif

/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif

/* exporting methods */
#if defined(__GNUC__)
#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#    ifndef GCC_HASCLASSVISIBILITY
#      define GCC_HASCLASSVISIBILITY
#    endif
#  endif
#endif

#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   if defined(STATIC_LINKED)
#     define SWIGEXPORT
#   else
#     define SWIGEXPORT __declspec(dllexport)
#   endif
# else
#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
#     define SWIGEXPORT __attribute__ ((visibility("default")))
#   else
#     define SWIGEXPORT
#   endif
# endif
#endif

/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   define SWIGSTDCALL __stdcall
# else
#   define SWIGSTDCALL
# endif
#endif

/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif

/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif

/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
#endif

/* Intel's compiler complains if a variable which was never initialised is
 * cast to void, which is a common idiom which we use to indicate that we
 * are aware a variable isn't used.  So we just silence that warning.
 * See: https://github.com/swig/swig/issues/192 for more discussion.
 */
#ifdef __INTEL_COMPILER
# pragma warning disable 592
#endif


#include <stdlib.h>
#include <string.h>
#include <stdio.h>


/* Support for throwing C# exceptions from C/C++. There are two types: 
 * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
typedef enum {
  SWIG_CSharpApplicationException,
  SWIG_CSharpArithmeticException,
  SWIG_CSharpDivideByZeroException,
  SWIG_CSharpIndexOutOfRangeException,
  SWIG_CSharpInvalidCastException,
  SWIG_CSharpInvalidOperationException,
  SWIG_CSharpIOException,
  SWIG_CSharpNullReferenceException,
  SWIG_CSharpOutOfMemoryException,
  SWIG_CSharpOverflowException,
  SWIG_CSharpSystemException
} SWIG_CSharpExceptionCodes;

typedef enum {
  SWIG_CSharpArgumentException,
  SWIG_CSharpArgumentNullException,
  SWIG_CSharpArgumentOutOfRangeException
} SWIG_CSharpExceptionArgumentCodes;

typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);

typedef struct {
  SWIG_CSharpExceptionCodes code;
  SWIG_CSharpExceptionCallback_t callback;
} SWIG_CSharpException_t;

typedef struct {
  SWIG_CSharpExceptionArgumentCodes code;
  SWIG_CSharpExceptionArgumentCallback_t callback;
} SWIG_CSharpExceptionArgument_t;

static SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
  { SWIG_CSharpApplicationException, NULL },
  { SWIG_CSharpArithmeticException, NULL },
  { SWIG_CSharpDivideByZeroException, NULL },
  { SWIG_CSharpIndexOutOfRangeException, NULL },
  { SWIG_CSharpInvalidCastException, NULL },
  { SWIG_CSharpInvalidOperationException, NULL },
  { SWIG_CSharpIOException, NULL },
  { SWIG_CSharpNullReferenceException, NULL },
  { SWIG_CSharpOutOfMemoryException, NULL },
  { SWIG_CSharpOverflowException, NULL },
  { SWIG_CSharpSystemException, NULL }
};

static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
  { SWIG_CSharpArgumentException, NULL },
  { SWIG_CSharpArgumentNullException, NULL },
  { SWIG_CSharpArgumentOutOfRangeException, NULL }
};

static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
  SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
  if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
    callback = SWIG_csharp_exceptions[code].callback;
  }
  callback(msg);
}

static void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
  SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
  if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
    callback = SWIG_csharp_exceptions_argument[code].callback;
  }
  callback(msg, param_name);
}


#ifdef __cplusplus
extern "C" 
#endif
SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_RobotRaconteurNET(
                                                SWIG_CSharpExceptionCallback_t applicationCallback,
                                                SWIG_CSharpExceptionCallback_t arithmeticCallback,
                                                SWIG_CSharpExceptionCallback_t divideByZeroCallback, 
                                                SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback, 
                                                SWIG_CSharpExceptionCallback_t invalidCastCallback,
                                                SWIG_CSharpExceptionCallback_t invalidOperationCallback,
                                                SWIG_CSharpExceptionCallback_t ioCallback,
                                                SWIG_CSharpExceptionCallback_t nullReferenceCallback,
                                                SWIG_CSharpExceptionCallback_t outOfMemoryCallback, 
                                                SWIG_CSharpExceptionCallback_t overflowCallback, 
                                                SWIG_CSharpExceptionCallback_t systemCallback) {
  SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
  SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
  SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
  SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
  SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
  SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
  SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
  SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
  SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
  SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
  SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
}

#ifdef __cplusplus
extern "C" 
#endif
SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_RobotRaconteurNET(
                                                SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
                                                SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
                                                SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
  SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
  SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
  SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
}


/* Callback for returning strings to C# without leaking memory */
typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
static SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;


#ifdef __cplusplus
extern "C" 
#endif
SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_RobotRaconteurNET(SWIG_CSharpStringHelperCallback callback) {
  SWIG_csharp_string_callback = callback;
}


/* Contract support */

#define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else

/* -----------------------------------------------------------------------------
 * director_common.swg
 *
 * This file contains support for director classes which is common between
 * languages.
 * ----------------------------------------------------------------------------- */

/*
  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
/* -----------------------------------------------------------------------------
 * director.swg
 *
 * This file contains support for director classes so that C# proxy
 * methods can be called from C++.
 * ----------------------------------------------------------------------------- */

#if defined(DEBUG_DIRECTOR_OWNED)
#include <iostream>
#endif
#include <string>
#include <exception>

namespace Swig {
  /* Director base class - not currently used in C# directors */
  class Director {
  };

  /* Base class for director exceptions */
  class DirectorException : public std::exception {
  protected:
    std::string swig_msg;

  public:
    DirectorException(const char *msg) : swig_msg(msg) {
    }

    DirectorException(const std::string &msg) : swig_msg(msg) {
    }

    virtual ~DirectorException() throw() {
    }

    const char *what() const throw() {
      return swig_msg.c_str();
    }
  };

  /* Pure virtual method exception */
  class DirectorPureVirtualException : public DirectorException {
  public:
    DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
    }

    static void raise(const char *msg) {
      throw DirectorPureVirtualException(msg);
    }
  };
}


#include <RobotRaconteur.h>
#include "RobotRaconteurWrapped.h"
#include <boost/lexical_cast.hpp>
#include <RobotRaconteur/RobotRaconteurServiceIndex_stubskel.h>
#include <boost/foreach.hpp>
using namespace RobotRaconteur;
using namespace std;


#include <string>


#include <typeinfo>
#include <stdexcept>


#include <vector>
#include <algorithm>
#include <stdexcept>


#include <map>
#include <algorithm>
#include <stdexcept>


#include <stdint.h>		// Use the C99 official header


#include <stdio.h>


#include <boost/filesystem/path.hpp>


class RobotRaconteurExceptionHelper
{
public:
virtual void SetRobotRaconteurException(const RobotRaconteur::HandlerErrorInfo& error) {};
virtual ~RobotRaconteurExceptionHelper() {}
};

RobotRaconteurExceptionHelper* robotRaconteurExceptionHelper=NULL;



template<class T> struct SWIG_intrusive_deleter {
    void operator()(T *p) {
        if (p) 
          intrusive_ptr_release(p);
    }
};

SWIGINTERN std::vector< std::string > *new_std_vector_Sl_std_string_Sg___SWIG_2(int capacity){
        std::vector< std::string >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< std::string >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN std::string std_vector_Sl_std_string_Sg__getitemcopy(std::vector< std::string > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< std::string >::value_type const &std_vector_Sl_std_string_Sg__getitem(std::vector< std::string > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__setitem(std::vector< std::string > *self,int index,std::string const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__AddRange(std::vector< std::string > *self,std::vector< std::string > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< std::string > *std_vector_Sl_std_string_Sg__GetRange(std::vector< std::string > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< std::string >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__Insert(std::vector< std::string > *self,int index,std::string const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__InsertRange(std::vector< std::string > *self,int index,std::vector< std::string > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__RemoveAt(std::vector< std::string > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__RemoveRange(std::vector< std::string > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< std::string > *std_vector_Sl_std_string_Sg__Repeat(std::string const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< std::string >(count, value);
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__Reverse__SWIG_0(std::vector< std::string > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__Reverse__SWIG_1(std::vector< std::string > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__SetRange(std::vector< std::string > *self,int index,std::vector< std::string > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_std_string_Sg__Contains(std::vector< std::string > *self,std::string const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_std_string_Sg__IndexOf(std::vector< std::string > *self,std::string const &value){
        int index = -1;
        std::vector< std::string >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_std_string_Sg__LastIndexOf(std::vector< std::string > *self,std::string const &value){
        int index = -1;
        std::vector< std::string >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_std_string_Sg__Remove(std::vector< std::string > *self,std::string const &value){
        std::vector< std::string >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }
SWIGINTERN std::vector< int32_t > *new_std_vector_Sl_int32_t_Sg___SWIG_2(int capacity){
        std::vector< int >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< int >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN int std_vector_Sl_int32_t_Sg__getitemcopy(std::vector< int32_t > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< int >::value_type const &std_vector_Sl_int32_t_Sg__getitem(std::vector< int32_t > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int32_t_Sg__setitem(std::vector< int32_t > *self,int index,int const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int32_t_Sg__AddRange(std::vector< int32_t > *self,std::vector< int > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< int > *std_vector_Sl_int32_t_Sg__GetRange(std::vector< int32_t > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< int >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_int32_t_Sg__Insert(std::vector< int32_t > *self,int index,int const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int32_t_Sg__InsertRange(std::vector< int32_t > *self,int index,std::vector< int > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int32_t_Sg__RemoveAt(std::vector< int32_t > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int32_t_Sg__RemoveRange(std::vector< int32_t > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< int > *std_vector_Sl_int32_t_Sg__Repeat(int const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< int >(count, value);
      }
SWIGINTERN void std_vector_Sl_int32_t_Sg__Reverse__SWIG_0(std::vector< int32_t > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_int32_t_Sg__Reverse__SWIG_1(std::vector< int32_t > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_int32_t_Sg__SetRange(std::vector< int32_t > *self,int index,std::vector< int > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_int32_t_Sg__Contains(std::vector< int32_t > *self,int const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_int32_t_Sg__IndexOf(std::vector< int32_t > *self,int const &value){
        int index = -1;
        std::vector< int >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_int32_t_Sg__LastIndexOf(std::vector< int32_t > *self,int const &value){
        int index = -1;
        std::vector< int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_int32_t_Sg__Remove(std::vector< int32_t > *self,int const &value){
        std::vector< int >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }
SWIGINTERN std::vector< uint32_t > *new_std_vector_Sl_uint32_t_Sg___SWIG_2(int capacity){
        std::vector< unsigned int >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< unsigned int >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN unsigned int std_vector_Sl_uint32_t_Sg__getitemcopy(std::vector< uint32_t > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< unsigned int >::value_type const &std_vector_Sl_uint32_t_Sg__getitem(std::vector< uint32_t > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_uint32_t_Sg__setitem(std::vector< uint32_t > *self,int index,unsigned int const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_uint32_t_Sg__AddRange(std::vector< uint32_t > *self,std::vector< unsigned int > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< unsigned int > *std_vector_Sl_uint32_t_Sg__GetRange(std::vector< uint32_t > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_uint32_t_Sg__Insert(std::vector< uint32_t > *self,int index,unsigned int const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_uint32_t_Sg__InsertRange(std::vector< uint32_t > *self,int index,std::vector< unsigned int > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_uint32_t_Sg__RemoveAt(std::vector< uint32_t > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_uint32_t_Sg__RemoveRange(std::vector< uint32_t > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< unsigned int > *std_vector_Sl_uint32_t_Sg__Repeat(unsigned int const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< unsigned int >(count, value);
      }
SWIGINTERN void std_vector_Sl_uint32_t_Sg__Reverse__SWIG_0(std::vector< uint32_t > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_uint32_t_Sg__Reverse__SWIG_1(std::vector< uint32_t > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_uint32_t_Sg__SetRange(std::vector< uint32_t > *self,int index,std::vector< unsigned int > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_uint32_t_Sg__Contains(std::vector< uint32_t > *self,unsigned int const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_uint32_t_Sg__IndexOf(std::vector< uint32_t > *self,unsigned int const &value){
        int index = -1;
        std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_uint32_t_Sg__LastIndexOf(std::vector< uint32_t > *self,unsigned int const &value){
        int index = -1;
        std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_uint32_t_Sg__Remove(std::vector< uint32_t > *self,unsigned int const &value){
        std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }
SWIGINTERN std::vector< int8_t > *new_std_vector_Sl_int8_t_Sg___SWIG_2(int capacity){
        std::vector< signed char >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< signed char >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN signed char std_vector_Sl_int8_t_Sg__getitemcopy(std::vector< int8_t > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< signed char >::value_type const &std_vector_Sl_int8_t_Sg__getitem(std::vector< int8_t > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int8_t_Sg__setitem(std::vector< int8_t > *self,int index,signed char const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int8_t_Sg__AddRange(std::vector< int8_t > *self,std::vector< signed char > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< signed char > *std_vector_Sl_int8_t_Sg__GetRange(std::vector< int8_t > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< signed char >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_int8_t_Sg__Insert(std::vector< int8_t > *self,int index,signed char const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int8_t_Sg__InsertRange(std::vector< int8_t > *self,int index,std::vector< signed char > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int8_t_Sg__RemoveAt(std::vector< int8_t > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int8_t_Sg__RemoveRange(std::vector< int8_t > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< signed char > *std_vector_Sl_int8_t_Sg__Repeat(signed char const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< signed char >(count, value);
      }
SWIGINTERN void std_vector_Sl_int8_t_Sg__Reverse__SWIG_0(std::vector< int8_t > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_int8_t_Sg__Reverse__SWIG_1(std::vector< int8_t > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_int8_t_Sg__SetRange(std::vector< int8_t > *self,int index,std::vector< signed char > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_int8_t_Sg__Contains(std::vector< int8_t > *self,signed char const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_int8_t_Sg__IndexOf(std::vector< int8_t > *self,signed char const &value){
        int index = -1;
        std::vector< signed char >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_int8_t_Sg__LastIndexOf(std::vector< int8_t > *self,signed char const &value){
        int index = -1;
        std::vector< signed char >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_int8_t_Sg__Remove(std::vector< int8_t > *self,signed char const &value){
        std::vector< signed char >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }
SWIGINTERN std::vector< uint8_t > *new_std_vector_Sl_uint8_t_Sg___SWIG_2(int capacity){
        std::vector< unsigned char >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< unsigned char >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN unsigned char std_vector_Sl_uint8_t_Sg__getitemcopy(std::vector< uint8_t > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< unsigned char >::value_type const &std_vector_Sl_uint8_t_Sg__getitem(std::vector< uint8_t > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_uint8_t_Sg__setitem(std::vector< uint8_t > *self,int index,unsigned char const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_uint8_t_Sg__AddRange(std::vector< uint8_t > *self,std::vector< unsigned char > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< unsigned char > *std_vector_Sl_uint8_t_Sg__GetRange(std::vector< uint8_t > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< unsigned char >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_uint8_t_Sg__Insert(std::vector< uint8_t > *self,int index,unsigned char const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_uint8_t_Sg__InsertRange(std::vector< uint8_t > *self,int index,std::vector< unsigned char > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_uint8_t_Sg__RemoveAt(std::vector< uint8_t > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_uint8_t_Sg__RemoveRange(std::vector< uint8_t > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< unsigned char > *std_vector_Sl_uint8_t_Sg__Repeat(unsigned char const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< unsigned char >(count, value);
      }
SWIGINTERN void std_vector_Sl_uint8_t_Sg__Reverse__SWIG_0(std::vector< uint8_t > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_uint8_t_Sg__Reverse__SWIG_1(std::vector< uint8_t > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_uint8_t_Sg__SetRange(std::vector< uint8_t > *self,int index,std::vector< unsigned char > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_uint8_t_Sg__Contains(std::vector< uint8_t > *self,unsigned char const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_uint8_t_Sg__IndexOf(std::vector< uint8_t > *self,unsigned char const &value){
        int index = -1;
        std::vector< unsigned char >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_uint8_t_Sg__LastIndexOf(std::vector< uint8_t > *self,unsigned char const &value){
        int index = -1;
        std::vector< unsigned char >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_uint8_t_Sg__Remove(std::vector< uint8_t > *self,unsigned char const &value){
        std::vector< unsigned char >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }
SWIGINTERN std::vector< uint64_t > *new_std_vector_Sl_uint64_t_Sg___SWIG_2(int capacity){
        std::vector< unsigned long long >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< unsigned long long >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN unsigned long long std_vector_Sl_uint64_t_Sg__getitemcopy(std::vector< uint64_t > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< unsigned long long >::value_type const &std_vector_Sl_uint64_t_Sg__getitem(std::vector< uint64_t > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_uint64_t_Sg__setitem(std::vector< uint64_t > *self,int index,unsigned long long const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_uint64_t_Sg__AddRange(std::vector< uint64_t > *self,std::vector< unsigned long long > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< unsigned long long > *std_vector_Sl_uint64_t_Sg__GetRange(std::vector< uint64_t > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< unsigned long long >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_uint64_t_Sg__Insert(std::vector< uint64_t > *self,int index,unsigned long long const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_uint64_t_Sg__InsertRange(std::vector< uint64_t > *self,int index,std::vector< unsigned long long > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_uint64_t_Sg__RemoveAt(std::vector< uint64_t > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_uint64_t_Sg__RemoveRange(std::vector< uint64_t > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< unsigned long long > *std_vector_Sl_uint64_t_Sg__Repeat(unsigned long long const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< unsigned long long >(count, value);
      }
SWIGINTERN void std_vector_Sl_uint64_t_Sg__Reverse__SWIG_0(std::vector< uint64_t > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_uint64_t_Sg__Reverse__SWIG_1(std::vector< uint64_t > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_uint64_t_Sg__SetRange(std::vector< uint64_t > *self,int index,std::vector< unsigned long long > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_uint64_t_Sg__Contains(std::vector< uint64_t > *self,unsigned long long const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_uint64_t_Sg__IndexOf(std::vector< uint64_t > *self,unsigned long long const &value){
        int index = -1;
        std::vector< unsigned long long >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_uint64_t_Sg__LastIndexOf(std::vector< uint64_t > *self,unsigned long long const &value){
        int index = -1;
        std::vector< unsigned long long >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_uint64_t_Sg__Remove(std::vector< uint64_t > *self,unsigned long long const &value){
        std::vector< unsigned long long >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }
SWIGINTERN std::map< std::string,std::string >::mapped_type const &std_map_Sl_std_string_Sc_std_string_Sg__getitem(std::map< std::string,std::string > *self,std::map< std::string,std::string >::key_type const &key){
        std::map< std::string, std::string, std::less< std::string > >::iterator iter = self->find(key);
        if (iter != self->end())
          return iter->second;
        else
          throw std::out_of_range("key not found");
      }
SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg__setitem(std::map< std::string,std::string > *self,std::map< std::string,std::string >::key_type const &key,std::map< std::string,std::string >::mapped_type const &x){
        (*self)[key] = x;
      }
SWIGINTERN bool std_map_Sl_std_string_Sc_std_string_Sg__ContainsKey(std::map< std::string,std::string > *self,std::map< std::string,std::string >::key_type const &key){
        std::map< std::string, std::string, std::less< std::string > >::iterator iter = self->find(key);
        return iter != self->end();
      }
SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg__Add(std::map< std::string,std::string > *self,std::map< std::string,std::string >::key_type const &key,std::map< std::string,std::string >::mapped_type const &value){
        std::map< std::string, std::string, std::less< std::string > >::iterator iter = self->find(key);
        if (iter != self->end())
          throw std::out_of_range("key already exists");
        self->insert(std::pair< std::string, std::string >(key, value));
      }
SWIGINTERN bool std_map_Sl_std_string_Sc_std_string_Sg__Remove(std::map< std::string,std::string > *self,std::map< std::string,std::string >::key_type const &key){
        std::map< std::string, std::string, std::less< std::string > >::iterator iter = self->find(key);
        if (iter != self->end()) {
          self->erase(iter);
          return true;
        }
        return false;
      }
SWIGINTERN std::map< std::string,std::string,std::less< std::string > >::iterator *std_map_Sl_std_string_Sc_std_string_Sg__create_iterator_begin(std::map< std::string,std::string > *self){
        return new std::map< std::string, std::string, std::less< std::string > >::iterator(self->begin());
      }
SWIGINTERN std::map< std::string,std::string >::key_type const &std_map_Sl_std_string_Sc_std_string_Sg__get_next_key(std::map< std::string,std::string > *self,std::map< std::string,std::string,std::less< std::string > >::iterator *swigiterator){
        std::map< std::string, std::string, std::less< std::string > >::iterator iter = *swigiterator;
        (*swigiterator)++;
        return (*iter).first;
      }
SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg__destroy_iterator(std::map< std::string,std::string > *self,std::map< std::string,std::string,std::less< std::string > >::iterator *swigiterator){
        delete swigiterator;
      }

struct SWIG_null_deleter {
  void operator() (void const *) const {
  }
};
#define SWIG_NO_NULL_DELETER_0 , SWIG_null_deleter()
#define SWIG_NO_NULL_DELETER_1
#define SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW
#define SWIG_NO_NULL_DELETER_SWIG_POINTER_OWN

SWIGINTERN std::vector< RobotRaconteur::ServicePathSegment > *new_std_vector_Sl_RobotRaconteur_ServicePathSegment_Sg___SWIG_2(int capacity){
        std::vector< RobotRaconteur::ServicePathSegment >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< RobotRaconteur::ServicePathSegment >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN RobotRaconteur::ServicePathSegment std_vector_Sl_RobotRaconteur_ServicePathSegment_Sg__getitemcopy(std::vector< RobotRaconteur::ServicePathSegment > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< RobotRaconteur::ServicePathSegment >::value_type const &std_vector_Sl_RobotRaconteur_ServicePathSegment_Sg__getitem(std::vector< RobotRaconteur::ServicePathSegment > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServicePathSegment_Sg__setitem(std::vector< RobotRaconteur::ServicePathSegment > *self,int index,RobotRaconteur::ServicePathSegment const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServicePathSegment_Sg__AddRange(std::vector< RobotRaconteur::ServicePathSegment > *self,std::vector< RobotRaconteur::ServicePathSegment > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< RobotRaconteur::ServicePathSegment > *std_vector_Sl_RobotRaconteur_ServicePathSegment_Sg__GetRange(std::vector< RobotRaconteur::ServicePathSegment > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< RobotRaconteur::ServicePathSegment >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServicePathSegment_Sg__Insert(std::vector< RobotRaconteur::ServicePathSegment > *self,int index,RobotRaconteur::ServicePathSegment const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServicePathSegment_Sg__InsertRange(std::vector< RobotRaconteur::ServicePathSegment > *self,int index,std::vector< RobotRaconteur::ServicePathSegment > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServicePathSegment_Sg__RemoveAt(std::vector< RobotRaconteur::ServicePathSegment > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServicePathSegment_Sg__RemoveRange(std::vector< RobotRaconteur::ServicePathSegment > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< RobotRaconteur::ServicePathSegment > *std_vector_Sl_RobotRaconteur_ServicePathSegment_Sg__Repeat(RobotRaconteur::ServicePathSegment const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< RobotRaconteur::ServicePathSegment >(count, value);
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServicePathSegment_Sg__Reverse__SWIG_0(std::vector< RobotRaconteur::ServicePathSegment > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServicePathSegment_Sg__Reverse__SWIG_1(std::vector< RobotRaconteur::ServicePathSegment > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServicePathSegment_Sg__SetRange(std::vector< RobotRaconteur::ServicePathSegment > *self,int index,std::vector< RobotRaconteur::ServicePathSegment > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *new_std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_TypeDefinition_Sg__Sg___SWIG_2(int capacity){
        std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN boost::shared_ptr< RobotRaconteur::TypeDefinition > std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_TypeDefinition_Sg__Sg__getitemcopy(std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > >::value_type const &std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_TypeDefinition_Sg__Sg__getitem(std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_TypeDefinition_Sg__Sg__setitem(std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *self,int index,boost::shared_ptr< RobotRaconteur::TypeDefinition > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_TypeDefinition_Sg__Sg__AddRange(std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *self,std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_TypeDefinition_Sg__Sg__GetRange(std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_TypeDefinition_Sg__Sg__Insert(std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *self,int index,boost::shared_ptr< RobotRaconteur::TypeDefinition > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_TypeDefinition_Sg__Sg__InsertRange(std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *self,int index,std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_TypeDefinition_Sg__Sg__RemoveAt(std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_TypeDefinition_Sg__Sg__RemoveRange(std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_TypeDefinition_Sg__Sg__Repeat(boost::shared_ptr< RobotRaconteur::TypeDefinition > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > >(count, value);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_TypeDefinition_Sg__Sg__Reverse__SWIG_0(std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_TypeDefinition_Sg__Sg__Reverse__SWIG_1(std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_TypeDefinition_Sg__Sg__SetRange(std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *self,int index,std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *new_std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_MemberDefinition_Sg__Sg___SWIG_2(int capacity){
        std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN boost::shared_ptr< RobotRaconteur::MemberDefinition > std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_MemberDefinition_Sg__Sg__getitemcopy(std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > >::value_type const &std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_MemberDefinition_Sg__Sg__getitem(std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_MemberDefinition_Sg__Sg__setitem(std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *self,int index,boost::shared_ptr< RobotRaconteur::MemberDefinition > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_MemberDefinition_Sg__Sg__AddRange(std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *self,std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_MemberDefinition_Sg__Sg__GetRange(std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_MemberDefinition_Sg__Sg__Insert(std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *self,int index,boost::shared_ptr< RobotRaconteur::MemberDefinition > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_MemberDefinition_Sg__Sg__InsertRange(std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *self,int index,std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_MemberDefinition_Sg__Sg__RemoveAt(std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_MemberDefinition_Sg__Sg__RemoveRange(std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_MemberDefinition_Sg__Sg__Repeat(boost::shared_ptr< RobotRaconteur::MemberDefinition > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > >(count, value);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_MemberDefinition_Sg__Sg__Reverse__SWIG_0(std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_MemberDefinition_Sg__Sg__Reverse__SWIG_1(std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_MemberDefinition_Sg__Sg__SetRange(std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *self,int index,std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *new_std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceEntryDefinition_Sg__Sg___SWIG_2(int capacity){
        std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceEntryDefinition_Sg__Sg__getitemcopy(std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > >::value_type const &std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceEntryDefinition_Sg__Sg__getitem(std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceEntryDefinition_Sg__Sg__setitem(std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *self,int index,boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceEntryDefinition_Sg__Sg__AddRange(std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *self,std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceEntryDefinition_Sg__Sg__GetRange(std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceEntryDefinition_Sg__Sg__Insert(std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *self,int index,boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceEntryDefinition_Sg__Sg__InsertRange(std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *self,int index,std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceEntryDefinition_Sg__Sg__RemoveAt(std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceEntryDefinition_Sg__Sg__RemoveRange(std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceEntryDefinition_Sg__Sg__Repeat(boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > >(count, value);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceEntryDefinition_Sg__Sg__Reverse__SWIG_0(std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceEntryDefinition_Sg__Sg__Reverse__SWIG_1(std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceEntryDefinition_Sg__Sg__SetRange(std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *self,int index,std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *new_std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ConstantDefinition_Sg__Sg___SWIG_2(int capacity){
        std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN boost::shared_ptr< RobotRaconteur::ConstantDefinition > std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ConstantDefinition_Sg__Sg__getitemcopy(std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > >::value_type const &std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ConstantDefinition_Sg__Sg__getitem(std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ConstantDefinition_Sg__Sg__setitem(std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *self,int index,boost::shared_ptr< RobotRaconteur::ConstantDefinition > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ConstantDefinition_Sg__Sg__AddRange(std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *self,std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ConstantDefinition_Sg__Sg__GetRange(std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ConstantDefinition_Sg__Sg__Insert(std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *self,int index,boost::shared_ptr< RobotRaconteur::ConstantDefinition > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ConstantDefinition_Sg__Sg__InsertRange(std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *self,int index,std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ConstantDefinition_Sg__Sg__RemoveAt(std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ConstantDefinition_Sg__Sg__RemoveRange(std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ConstantDefinition_Sg__Sg__Repeat(boost::shared_ptr< RobotRaconteur::ConstantDefinition > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > >(count, value);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ConstantDefinition_Sg__Sg__Reverse__SWIG_0(std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ConstantDefinition_Sg__Sg__Reverse__SWIG_1(std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ConstantDefinition_Sg__Sg__SetRange(std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *self,int index,std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *new_std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_EnumDefinition_Sg__Sg___SWIG_2(int capacity){
        std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN boost::shared_ptr< RobotRaconteur::EnumDefinition > std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_EnumDefinition_Sg__Sg__getitemcopy(std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > >::value_type const &std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_EnumDefinition_Sg__Sg__getitem(std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_EnumDefinition_Sg__Sg__setitem(std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *self,int index,boost::shared_ptr< RobotRaconteur::EnumDefinition > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_EnumDefinition_Sg__Sg__AddRange(std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *self,std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_EnumDefinition_Sg__Sg__GetRange(std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_EnumDefinition_Sg__Sg__Insert(std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *self,int index,boost::shared_ptr< RobotRaconteur::EnumDefinition > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_EnumDefinition_Sg__Sg__InsertRange(std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *self,int index,std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_EnumDefinition_Sg__Sg__RemoveAt(std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_EnumDefinition_Sg__Sg__RemoveRange(std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_EnumDefinition_Sg__Sg__Repeat(boost::shared_ptr< RobotRaconteur::EnumDefinition > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > >(count, value);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_EnumDefinition_Sg__Sg__Reverse__SWIG_0(std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_EnumDefinition_Sg__Sg__Reverse__SWIG_1(std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_EnumDefinition_Sg__Sg__SetRange(std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *self,int index,std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::vector< RobotRaconteur::ConstantDefinition_StructField > *new_std_vector_Sl_RobotRaconteur_ConstantDefinition_StructField_Sg___SWIG_2(int capacity){
        std::vector< RobotRaconteur::ConstantDefinition_StructField >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< RobotRaconteur::ConstantDefinition_StructField >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN RobotRaconteur::ConstantDefinition_StructField std_vector_Sl_RobotRaconteur_ConstantDefinition_StructField_Sg__getitemcopy(std::vector< RobotRaconteur::ConstantDefinition_StructField > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< RobotRaconteur::ConstantDefinition_StructField >::value_type const &std_vector_Sl_RobotRaconteur_ConstantDefinition_StructField_Sg__getitem(std::vector< RobotRaconteur::ConstantDefinition_StructField > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ConstantDefinition_StructField_Sg__setitem(std::vector< RobotRaconteur::ConstantDefinition_StructField > *self,int index,RobotRaconteur::ConstantDefinition_StructField const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ConstantDefinition_StructField_Sg__AddRange(std::vector< RobotRaconteur::ConstantDefinition_StructField > *self,std::vector< RobotRaconteur::ConstantDefinition_StructField > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< RobotRaconteur::ConstantDefinition_StructField > *std_vector_Sl_RobotRaconteur_ConstantDefinition_StructField_Sg__GetRange(std::vector< RobotRaconteur::ConstantDefinition_StructField > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< RobotRaconteur::ConstantDefinition_StructField >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ConstantDefinition_StructField_Sg__Insert(std::vector< RobotRaconteur::ConstantDefinition_StructField > *self,int index,RobotRaconteur::ConstantDefinition_StructField const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ConstantDefinition_StructField_Sg__InsertRange(std::vector< RobotRaconteur::ConstantDefinition_StructField > *self,int index,std::vector< RobotRaconteur::ConstantDefinition_StructField > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ConstantDefinition_StructField_Sg__RemoveAt(std::vector< RobotRaconteur::ConstantDefinition_StructField > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ConstantDefinition_StructField_Sg__RemoveRange(std::vector< RobotRaconteur::ConstantDefinition_StructField > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< RobotRaconteur::ConstantDefinition_StructField > *std_vector_Sl_RobotRaconteur_ConstantDefinition_StructField_Sg__Repeat(RobotRaconteur::ConstantDefinition_StructField const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< RobotRaconteur::ConstantDefinition_StructField >(count, value);
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ConstantDefinition_StructField_Sg__Reverse__SWIG_0(std::vector< RobotRaconteur::ConstantDefinition_StructField > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ConstantDefinition_StructField_Sg__Reverse__SWIG_1(std::vector< RobotRaconteur::ConstantDefinition_StructField > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ConstantDefinition_StructField_Sg__SetRange(std::vector< RobotRaconteur::ConstantDefinition_StructField > *self,int index,std::vector< RobotRaconteur::ConstantDefinition_StructField > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::vector< RobotRaconteur::EnumDefinitionValue > *new_std_vector_Sl_RobotRaconteur_EnumDefinitionValue_Sg___SWIG_2(int capacity){
        std::vector< RobotRaconteur::EnumDefinitionValue >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< RobotRaconteur::EnumDefinitionValue >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN RobotRaconteur::EnumDefinitionValue std_vector_Sl_RobotRaconteur_EnumDefinitionValue_Sg__getitemcopy(std::vector< RobotRaconteur::EnumDefinitionValue > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< RobotRaconteur::EnumDefinitionValue >::value_type const &std_vector_Sl_RobotRaconteur_EnumDefinitionValue_Sg__getitem(std::vector< RobotRaconteur::EnumDefinitionValue > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_EnumDefinitionValue_Sg__setitem(std::vector< RobotRaconteur::EnumDefinitionValue > *self,int index,RobotRaconteur::EnumDefinitionValue const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_EnumDefinitionValue_Sg__AddRange(std::vector< RobotRaconteur::EnumDefinitionValue > *self,std::vector< RobotRaconteur::EnumDefinitionValue > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< RobotRaconteur::EnumDefinitionValue > *std_vector_Sl_RobotRaconteur_EnumDefinitionValue_Sg__GetRange(std::vector< RobotRaconteur::EnumDefinitionValue > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< RobotRaconteur::EnumDefinitionValue >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_EnumDefinitionValue_Sg__Insert(std::vector< RobotRaconteur::EnumDefinitionValue > *self,int index,RobotRaconteur::EnumDefinitionValue const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_EnumDefinitionValue_Sg__InsertRange(std::vector< RobotRaconteur::EnumDefinitionValue > *self,int index,std::vector< RobotRaconteur::EnumDefinitionValue > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_EnumDefinitionValue_Sg__RemoveAt(std::vector< RobotRaconteur::EnumDefinitionValue > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_EnumDefinitionValue_Sg__RemoveRange(std::vector< RobotRaconteur::EnumDefinitionValue > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< RobotRaconteur::EnumDefinitionValue > *std_vector_Sl_RobotRaconteur_EnumDefinitionValue_Sg__Repeat(RobotRaconteur::EnumDefinitionValue const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< RobotRaconteur::EnumDefinitionValue >(count, value);
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_EnumDefinitionValue_Sg__Reverse__SWIG_0(std::vector< RobotRaconteur::EnumDefinitionValue > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_EnumDefinitionValue_Sg__Reverse__SWIG_1(std::vector< RobotRaconteur::EnumDefinitionValue > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_EnumDefinitionValue_Sg__SetRange(std::vector< RobotRaconteur::EnumDefinitionValue > *self,int index,std::vector< RobotRaconteur::EnumDefinitionValue > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *new_std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_UsingDefinition_Sg__Sg___SWIG_2(int capacity){
        std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN boost::shared_ptr< RobotRaconteur::UsingDefinition > std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_UsingDefinition_Sg__Sg__getitemcopy(std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > >::value_type const &std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_UsingDefinition_Sg__Sg__getitem(std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_UsingDefinition_Sg__Sg__setitem(std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *self,int index,boost::shared_ptr< RobotRaconteur::UsingDefinition > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_UsingDefinition_Sg__Sg__AddRange(std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *self,std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_UsingDefinition_Sg__Sg__GetRange(std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_UsingDefinition_Sg__Sg__Insert(std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *self,int index,boost::shared_ptr< RobotRaconteur::UsingDefinition > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_UsingDefinition_Sg__Sg__InsertRange(std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *self,int index,std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_UsingDefinition_Sg__Sg__RemoveAt(std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_UsingDefinition_Sg__Sg__RemoveRange(std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_UsingDefinition_Sg__Sg__Repeat(boost::shared_ptr< RobotRaconteur::UsingDefinition > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > >(count, value);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_UsingDefinition_Sg__Sg__Reverse__SWIG_0(std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_UsingDefinition_Sg__Sg__Reverse__SWIG_1(std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_UsingDefinition_Sg__Sg__SetRange(std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *self,int index,std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *new_std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ExceptionDefinition_Sg__Sg___SWIG_2(int capacity){
        std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN boost::shared_ptr< RobotRaconteur::ExceptionDefinition > std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ExceptionDefinition_Sg__Sg__getitemcopy(std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > >::value_type const &std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ExceptionDefinition_Sg__Sg__getitem(std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ExceptionDefinition_Sg__Sg__setitem(std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *self,int index,boost::shared_ptr< RobotRaconteur::ExceptionDefinition > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ExceptionDefinition_Sg__Sg__AddRange(std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *self,std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ExceptionDefinition_Sg__Sg__GetRange(std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ExceptionDefinition_Sg__Sg__Insert(std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *self,int index,boost::shared_ptr< RobotRaconteur::ExceptionDefinition > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ExceptionDefinition_Sg__Sg__InsertRange(std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *self,int index,std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ExceptionDefinition_Sg__Sg__RemoveAt(std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ExceptionDefinition_Sg__Sg__RemoveRange(std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ExceptionDefinition_Sg__Sg__Repeat(boost::shared_ptr< RobotRaconteur::ExceptionDefinition > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > >(count, value);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ExceptionDefinition_Sg__Sg__Reverse__SWIG_0(std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ExceptionDefinition_Sg__Sg__Reverse__SWIG_1(std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ExceptionDefinition_Sg__Sg__SetRange(std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *self,int index,std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *new_std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceDefinition_Sg__Sg___SWIG_2(int capacity){
        std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN boost::shared_ptr< RobotRaconteur::ServiceDefinition > std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceDefinition_Sg__Sg__getitemcopy(std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > >::value_type const &std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceDefinition_Sg__Sg__getitem(std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceDefinition_Sg__Sg__setitem(std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *self,int index,boost::shared_ptr< RobotRaconteur::ServiceDefinition > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceDefinition_Sg__Sg__AddRange(std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *self,std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceDefinition_Sg__Sg__GetRange(std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceDefinition_Sg__Sg__Insert(std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *self,int index,boost::shared_ptr< RobotRaconteur::ServiceDefinition > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceDefinition_Sg__Sg__InsertRange(std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *self,int index,std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceDefinition_Sg__Sg__RemoveAt(std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceDefinition_Sg__Sg__RemoveRange(std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceDefinition_Sg__Sg__Repeat(boost::shared_ptr< RobotRaconteur::ServiceDefinition > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > >(count, value);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceDefinition_Sg__Sg__Reverse__SWIG_0(std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceDefinition_Sg__Sg__Reverse__SWIG_1(std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceDefinition_Sg__Sg__SetRange(std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *self,int index,std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN boost::shared_ptr< RobotRaconteur::ServiceDefinition > RobotRaconteur_ServiceEntryDefinition_GetServiceDefinition(RobotRaconteur::ServiceEntryDefinition *self){
		return self->ServiceDefinition_.lock();
	}
SWIGINTERN void RobotRaconteur_ServiceEntryDefinition_SetServiceDefinition(RobotRaconteur::ServiceEntryDefinition *self,boost::shared_ptr< RobotRaconteur::ServiceDefinition > const &value){
		self->ServiceDefinition_=value;
	}
SWIGINTERN boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > RobotRaconteur_MemberDefinition_GetServiceEntry(RobotRaconteur::MemberDefinition *self){
		return self->ServiceEntry.lock();
	}
SWIGINTERN void RobotRaconteur_MemberDefinition_SetServiceEntry(RobotRaconteur::MemberDefinition *self,boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > const &value){
		self->ServiceEntry=value;
	}
SWIGINTERN boost::shared_ptr< RobotRaconteur::MemberDefinition > RobotRaconteur_TypeDefinition_GetMember(RobotRaconteur::TypeDefinition *self){
		return self->member.lock();
	}
SWIGINTERN void RobotRaconteur_TypeDefinition_SetMember(RobotRaconteur::TypeDefinition *self,boost::shared_ptr< RobotRaconteur::MemberDefinition > const &value){
		self->member=value;
	}
SWIGINTERN boost::shared_ptr< RobotRaconteur::ServiceDefinition > RobotRaconteur_UsingDefinition_GetService(RobotRaconteur::UsingDefinition *self){
			return self->service.lock();
		}
SWIGINTERN void RobotRaconteur_UsingDefinition_SetService(RobotRaconteur::UsingDefinition *self,boost::shared_ptr< RobotRaconteur::ServiceDefinition > const &value){
			self->service=value;
		}
SWIGINTERN boost::shared_ptr< RobotRaconteur::ServiceDefinition > RobotRaconteur_ConstantDefinition_GetService(RobotRaconteur::ConstantDefinition *self){
			return self->service.lock();
		}
SWIGINTERN void RobotRaconteur_ConstantDefinition_SetService(RobotRaconteur::ConstantDefinition *self,boost::shared_ptr< RobotRaconteur::ServiceDefinition > const &value){
			self->service=value;
		}
SWIGINTERN boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > RobotRaconteur_ConstantDefinition_GetServiceEntry(RobotRaconteur::ConstantDefinition *self){
			return self->service_entry.lock();
		}
SWIGINTERN void RobotRaconteur_ConstantDefinition_SetServiceEntry(RobotRaconteur::ConstantDefinition *self,boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > const &value){
			self->service_entry=value;
		}
SWIGINTERN boost::shared_ptr< RobotRaconteur::ServiceDefinition > RobotRaconteur_EnumDefinition_GetService(RobotRaconteur::EnumDefinition *self){
			return self->service.lock();
		}
SWIGINTERN void RobotRaconteur_EnumDefinition_SetService(RobotRaconteur::EnumDefinition *self,boost::shared_ptr< RobotRaconteur::ServiceDefinition > const &value){
			self->service=value;
		}
SWIGINTERN boost::shared_ptr< RobotRaconteur::ServiceDefinition > RobotRaconteur_ExceptionDefinition_GetService(RobotRaconteur::ExceptionDefinition *self){
			return self->service.lock();
		}
SWIGINTERN void RobotRaconteur_ExceptionDefinition_SetService(RobotRaconteur::ExceptionDefinition *self,boost::shared_ptr< RobotRaconteur::ServiceDefinition > const &value){
			self->service=value;
		}


class MemberDefinitionUtil
{
public:
static boost::shared_ptr<RobotRaconteur::PropertyDefinition> ToProperty(const boost::shared_ptr<RobotRaconteur::MemberDefinition>& t)
{
return boost::dynamic_pointer_cast<RobotRaconteur::PropertyDefinition>(t);
}

static boost::shared_ptr<RobotRaconteur::FunctionDefinition> ToFunction(const boost::shared_ptr<RobotRaconteur::MemberDefinition>& t)
{
return boost::dynamic_pointer_cast<RobotRaconteur::FunctionDefinition>(t);
}

static boost::shared_ptr<RobotRaconteur::ObjRefDefinition> ToObjRef(const boost::shared_ptr<RobotRaconteur::MemberDefinition>& t)
{
return boost::dynamic_pointer_cast<RobotRaconteur::ObjRefDefinition>(t);
}

static boost::shared_ptr<RobotRaconteur::EventDefinition> ToEvent(const boost::shared_ptr<RobotRaconteur::MemberDefinition>& t)
{
return boost::dynamic_pointer_cast<RobotRaconteur::EventDefinition>(t);
}

static boost::shared_ptr<RobotRaconteur::PipeDefinition> ToPipe(const boost::shared_ptr<RobotRaconteur::MemberDefinition>& t)
{
return boost::dynamic_pointer_cast<RobotRaconteur::PipeDefinition>(t);
}

static boost::shared_ptr<RobotRaconteur::CallbackDefinition> ToCallback(const boost::shared_ptr<RobotRaconteur::MemberDefinition>& t)
{
return boost::dynamic_pointer_cast<RobotRaconteur::CallbackDefinition>(t);
}

static boost::shared_ptr<RobotRaconteur::WireDefinition> ToWire(const boost::shared_ptr<RobotRaconteur::MemberDefinition>& t)
{
return boost::dynamic_pointer_cast<RobotRaconteur::WireDefinition>(t);
}

static boost::shared_ptr<RobotRaconteur::MemoryDefinition> ToMemory(const boost::shared_ptr<RobotRaconteur::MemberDefinition>& t)
{
return boost::dynamic_pointer_cast<RobotRaconteur::MemoryDefinition>(t);
}

};

SWIGINTERN RobotRaconteur::NodeID *new_RobotRaconteur_NodeID__SWIG_3(uint8_t const bytes[16],int32_t bytes_len){
		if (bytes_len!=16) throw InvalidArgumentException("Invalid NodeID bytes length");

		boost::array<uint8_t,16> b = {};
		memcpy(&b[0],bytes,16);

		NodeID* n=new NodeID(b);
		return n;
	}
SWIGINTERN void RobotRaconteur_NodeID_ToByteArray(RobotRaconteur::NodeID *self,uint8_t bytes[16]){
		boost::array<uint8_t,16> b=self->ToByteArray();
		memcpy(bytes,&b[0],16);
	}
SWIGINTERN std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *new_std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageEntry_Sg__Sg___SWIG_2(int capacity){
        std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN boost::intrusive_ptr< RobotRaconteur::MessageEntry > std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageEntry_Sg__Sg__getitemcopy(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > >::value_type const &std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageEntry_Sg__Sg__getitem(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageEntry_Sg__Sg__setitem(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *self,int index,boost::intrusive_ptr< RobotRaconteur::MessageEntry > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageEntry_Sg__Sg__AddRange(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *self,std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageEntry_Sg__Sg__GetRange(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageEntry_Sg__Sg__Insert(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *self,int index,boost::intrusive_ptr< RobotRaconteur::MessageEntry > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageEntry_Sg__Sg__InsertRange(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *self,int index,std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageEntry_Sg__Sg__RemoveAt(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageEntry_Sg__Sg__RemoveRange(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageEntry_Sg__Sg__Repeat(boost::intrusive_ptr< RobotRaconteur::MessageEntry > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > >(count, value);
      }
SWIGINTERN void std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageEntry_Sg__Sg__Reverse__SWIG_0(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageEntry_Sg__Sg__Reverse__SWIG_1(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageEntry_Sg__Sg__SetRange(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *self,int index,std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *new_std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageElement_Sg__Sg___SWIG_2(int capacity){
        std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN boost::intrusive_ptr< RobotRaconteur::MessageElement > std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageElement_Sg__Sg__getitemcopy(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > >::value_type const &std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageElement_Sg__Sg__getitem(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageElement_Sg__Sg__setitem(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *self,int index,boost::intrusive_ptr< RobotRaconteur::MessageElement > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageElement_Sg__Sg__AddRange(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *self,std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageElement_Sg__Sg__GetRange(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageElement_Sg__Sg__Insert(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *self,int index,boost::intrusive_ptr< RobotRaconteur::MessageElement > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageElement_Sg__Sg__InsertRange(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *self,int index,std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageElement_Sg__Sg__RemoveAt(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageElement_Sg__Sg__RemoveRange(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageElement_Sg__Sg__Repeat(boost::intrusive_ptr< RobotRaconteur::MessageElement > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > >(count, value);
      }
SWIGINTERN void std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageElement_Sg__Sg__Reverse__SWIG_0(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageElement_Sg__Sg__Reverse__SWIG_1(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageElement_Sg__Sg__SetRange(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *self,int index,std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }


class MessageElementDataUtil
{
public:
	static boost::intrusive_ptr<RobotRaconteur::RRBaseArray> ToRRBaseArray(const boost::intrusive_ptr<RobotRaconteur::MessageElementData>& m)
	{
		return boost::dynamic_pointer_cast<RRBaseArray>(m);
	}

	static boost::intrusive_ptr<RobotRaconteur::MessageElementNestedElementList> ToMessageElementNestedElementList(const boost::intrusive_ptr<RobotRaconteur::MessageElementData>& m)
	{
		return boost::dynamic_pointer_cast<MessageElementNestedElementList>(m);
	}



	static std::string RRBaseArrayToString(const boost::intrusive_ptr<RobotRaconteur::RRBaseArray>& rrarray)
	{
		return RRArrayToString(rr_cast<RRArray<char> >(rrarray));
	}

	static void RRBaseArrayToDoubles(const boost::intrusive_ptr<RobotRaconteur::RRBaseArray>& rrarray, double* array_out, int32_t len)
	{
		if (rrarray->GetTypeID()!=DataTypes_double_t) throw InvalidArgumentException("RRArray error");
		if (rrarray->size()!=len) throw InvalidArgumentException("RRArray error");
		memcpy(array_out,rrarray->void_ptr(),len*sizeof(double));
	}

	static void RRBaseArrayToFloats(const boost::intrusive_ptr<RobotRaconteur::RRBaseArray>& rrarray, float* array_out, int32_t len)
	{
		if (rrarray->GetTypeID()!=DataTypes_single_t) throw InvalidArgumentException("RRArray error");
		if (rrarray->size()!=len) throw InvalidArgumentException("RRArray error");
		memcpy(array_out,rrarray->void_ptr(),len*sizeof(float));
	}

	static void RRBaseArrayToBytes(const boost::intrusive_ptr<RobotRaconteur::RRBaseArray>& rrarray, int8_t* array_out, int32_t len)
	{
		if (rrarray->GetTypeID()!=DataTypes_int8_t && rrarray->GetTypeID()!=DataTypes_uint8_t) throw InvalidArgumentException("RRArray error");
		if (rrarray->size()!=len) throw InvalidArgumentException("RRArray error");
		memcpy(array_out,rrarray->void_ptr(),len*sizeof(int8_t));

	}

	static void RRBaseArrayToBytes(const boost::intrusive_ptr<RobotRaconteur::RRBaseArray>& rrarray, uint8_t* array_out, int32_t len)
	{
		if (rrarray->GetTypeID()!=DataTypes_uint8_t) throw InvalidArgumentException("RRArray error");
		if (rrarray->size()!=len) throw InvalidArgumentException("RRArray error");
		memcpy(array_out,rrarray->void_ptr(),len*sizeof(uint8_t));
	}

	static void RRBaseArrayToShorts(const boost::intrusive_ptr<RobotRaconteur::RRBaseArray>& rrarray, int16_t* array_out, int32_t len)
	{
		if (rrarray->GetTypeID()!=DataTypes_int16_t && rrarray->GetTypeID()!=DataTypes_uint16_t) throw InvalidArgumentException("RRArray error");
		if (rrarray->size()!=len) throw InvalidArgumentException("RRArray error");
		memcpy(array_out,rrarray->void_ptr(),len*sizeof(int16_t));
	}

	static void RRBaseArrayToShorts(const boost::intrusive_ptr<RobotRaconteur::RRBaseArray>& rrarray, uint16_t* array_out, int32_t len)
	{
		if (rrarray->GetTypeID()!=DataTypes_uint16_t) throw InvalidArgumentException("RRArray error");
		if (rrarray->size()!=len) throw InvalidArgumentException("RRArray error");
		memcpy(array_out,rrarray->void_ptr(),len*sizeof(uint16_t));
	}

	static void RRBaseArrayToInts(const boost::intrusive_ptr<RobotRaconteur::RRBaseArray>& rrarray, int32_t* array_out, int32_t len)
	{
		if (rrarray->GetTypeID()!=DataTypes_int32_t && rrarray->GetTypeID()!=DataTypes_uint32_t) throw InvalidArgumentException("RRArray error");
		if (rrarray->size()!=len) throw InvalidArgumentException("RRArray error");
		memcpy(array_out,rrarray->void_ptr(),len*sizeof(int32_t));
	}

	static void RRBaseArrayToInts(const boost::intrusive_ptr<RobotRaconteur::RRBaseArray>& rrarray, uint32_t* array_out, int32_t len)
	{
		if (rrarray->GetTypeID()!=DataTypes_uint32_t) throw InvalidArgumentException("RRArray error");
		if (rrarray->size()!=len) throw InvalidArgumentException("RRArray error");
		memcpy(array_out,rrarray->void_ptr(),len*sizeof(uint32_t));
	}

	static void RRBaseArrayToLongs(const boost::intrusive_ptr<RobotRaconteur::RRBaseArray>& rrarray, int64_t* array_out, int32_t len)
	{
		if (rrarray->GetTypeID()!=DataTypes_int64_t && rrarray->GetTypeID()!=DataTypes_uint64_t) throw InvalidArgumentException("RRArray error");
		if (rrarray->size()!=len) throw InvalidArgumentException("RRArray error");
		memcpy(array_out,rrarray->void_ptr(),len*sizeof(int64_t));
	}


	static void RRBaseArrayToLongs(const boost::intrusive_ptr<RobotRaconteur::RRBaseArray>& rrarray, uint64_t* array_out, int32_t len)
	{
		if (rrarray->GetTypeID()!=DataTypes_uint64_t) throw InvalidArgumentException("RRArray error");
		if (rrarray->size()!=len) throw InvalidArgumentException("RRArray error");
		memcpy(array_out,rrarray->void_ptr(),len*sizeof(uint64_t));
	}

	static void RRBaseArrayComplexToDoubles(const boost::intrusive_ptr<RobotRaconteur::RRBaseArray>& rrarray, double* array_out, int32_t len)
	{
		if (rrarray->GetTypeID()!=DataTypes_cdouble_t) throw InvalidArgumentException("RRArray error");
		if (rrarray->size()!=len/2) throw InvalidArgumentException("RRArray error");
		memcpy(array_out,rrarray->void_ptr(),len*sizeof(double));
	}

	static void RRBaseArrayComplexToFloats(const boost::intrusive_ptr<RobotRaconteur::RRBaseArray>& rrarray, float* array_out, int32_t len)
	{
		if (rrarray->GetTypeID()!=DataTypes_csingle_t) throw InvalidArgumentException("RRArray error");
		if (rrarray->size()!=len/2) throw InvalidArgumentException("RRArray error");
		memcpy(array_out,rrarray->void_ptr(),len*sizeof(float));
	}

	static void RRBaseArrayBoolToBytes(const boost::intrusive_ptr<RobotRaconteur::RRBaseArray>& rrarray, uint8_t* array_out, int32_t len)
	{
		if (rrarray->GetTypeID()!=DataTypes_bool_t) throw InvalidArgumentException("RRArray error");
		if (rrarray->size()!=len) throw InvalidArgumentException("RRArray error");
		memcpy(array_out,rrarray->void_ptr(),len*sizeof(uint8_t));
	}

	static void RRBaseArrayBoolToBytes(const boost::intrusive_ptr<RobotRaconteur::RRBaseArray>& rrarray, int8_t* array_out, int32_t len)
	{
		if (rrarray->GetTypeID()!=DataTypes_bool_t) throw InvalidArgumentException("RRArray error");
		if (rrarray->size()!=len) throw InvalidArgumentException("RRArray error");
		memcpy(array_out,rrarray->void_ptr(),len*sizeof(int8_t));
	}

	static boost::intrusive_ptr<RobotRaconteur::RRBaseArray> stringToRRBaseArray(const std::string& str)
	{
		return stringToRRArray(str);
	}

	static boost::intrusive_ptr<RobotRaconteur::RRBaseArray> DoublesToRRBaseArray(double* array_in, int32_t len)
	{
		return AttachRRArrayCopy(array_in,len);
	}

	static boost::intrusive_ptr<RobotRaconteur::RRBaseArray> FloatsToRRBaseArray(float* array_in, int32_t len)
	{
		return AttachRRArrayCopy(array_in,len);
	}

	static boost::intrusive_ptr<RobotRaconteur::RRBaseArray>  BytesToRRBaseArray( int8_t* array_in, int32_t len, RobotRaconteur::DataTypes type)
	{
		if (type == DataTypes_int8_t) return AttachRRArrayCopy(array_in,len);
		if (type == DataTypes_uint8_t) return AttachRRArrayCopy((uint8_t*)array_in,len);
		throw DataTypeException("Invalid data type");

	}

	static boost::intrusive_ptr<RobotRaconteur::RRBaseArray>  BytesToRRBaseArray( uint8_t* array_in, int32_t len)
	{
		return AttachRRArrayCopy(array_in,len);
	}

	static boost::intrusive_ptr<RobotRaconteur::RRBaseArray>  ShortsToRRBaseArray( int16_t* array_in, int32_t len, RobotRaconteur::DataTypes type)
	{
		if (type == DataTypes_int16_t) return AttachRRArrayCopy(array_in,len);
		if (type == DataTypes_uint16_t) return AttachRRArrayCopy((uint16_t*)array_in,len);
		throw DataTypeException("Invalid data type");
	}

	static boost::intrusive_ptr<RobotRaconteur::RRBaseArray>  ShortsToRRBaseArray( uint16_t* array_in, int32_t len)
	{
		return AttachRRArrayCopy(array_in,len);
	}

	static boost::intrusive_ptr<RobotRaconteur::RRBaseArray>  IntsToRRBaseArray( int32_t* array_in, int32_t len, RobotRaconteur::DataTypes type)
	{
		if (type == DataTypes_int32_t) return AttachRRArrayCopy(array_in,len);
		if (type == DataTypes_uint32_t) return AttachRRArrayCopy((uint32_t*)array_in,len);
		throw DataTypeException("Invalid data type");

	}

	static boost::intrusive_ptr<RobotRaconteur::RRBaseArray>  IntsToRRBaseArray( uint32_t* array_in, int32_t len)
	{
		return AttachRRArrayCopy(array_in,len);
	}

	static boost::intrusive_ptr<RobotRaconteur::RRBaseArray>  LongsToRRBaseArray( int64_t* array_in, int32_t len, RobotRaconteur::DataTypes type)
	{
		if (type == DataTypes_int64_t) return AttachRRArrayCopy(array_in,len);
		if (type == DataTypes_uint64_t) return AttachRRArrayCopy((uint64_t*)array_in,len);
		throw DataTypeException("Invalid data type");

	}

	static boost::intrusive_ptr<RobotRaconteur::RRBaseArray>  LongsToRRBaseArray( uint64_t* array_in, int32_t len)
	{
		return AttachRRArrayCopy(array_in,len);

	}

	static boost::intrusive_ptr<RobotRaconteur::RRBaseArray> DoublesToComplexRRBaseArray(double* array_in, int32_t len)
	{
		if (len %2 != 0) throw InvalidArgumentException("Array must be even length");
		return AttachRRArrayCopy((cdouble*)array_in,len/2);
	}

	static boost::intrusive_ptr<RobotRaconteur::RRBaseArray> FloatsToComplexRRBaseArray(float* array_in, int32_t len)
	{
		if (len %2 != 0) throw InvalidArgumentException("Array must be even length");
		return AttachRRArrayCopy((cfloat*)array_in,len/2);
	}

	static boost::intrusive_ptr<RobotRaconteur::RRBaseArray> BytesToBoolRRBaseArray(uint8_t* array_in, int32_t len)
	{
		return AttachRRArrayCopy((rr_bool*)array_in,len);
	}

	static boost::intrusive_ptr<RobotRaconteur::RRBaseArray> BytesToBoolRRBaseArray(int8_t* array_in, int32_t len)
	{
		return AttachRRArrayCopy((rr_bool*)array_in,len);
	}

	static void DoublesToRRBaseArray(double* array_in, int32_t len,const boost::intrusive_ptr<RobotRaconteur::RRBaseArray>& rrarray)
	{
		if (rrarray->GetTypeID()!=DataTypes_double_t) throw InvalidArgumentException("RRArray error");
		if (rrarray->size()!=len) throw InvalidArgumentException("RRArray error");
		memcpy(rrarray->void_ptr(),array_in,len*sizeof(double));
	}

	static void FloatsToRRBaseArray(float* array_in, int32_t len,const boost::intrusive_ptr<RobotRaconteur::RRBaseArray>& rrarray)
	{
		if (rrarray->GetTypeID()!=DataTypes_single_t) throw InvalidArgumentException("RRArray error");
		if (rrarray->size()!=len) throw InvalidArgumentException("RRArray error");
		memcpy(rrarray->void_ptr(),array_in,len*sizeof(float));
	}

	static  void BytesToRRBaseArray( int8_t* array_in, int32_t len,const boost::intrusive_ptr<RobotRaconteur::RRBaseArray>& rrarray)
	{
		if (rrarray->GetTypeID()!=DataTypes_int8_t && rrarray->GetTypeID()!=DataTypes_uint8_t) throw InvalidArgumentException("RRArray error");
		if (rrarray->size()!=len) throw InvalidArgumentException("RRArray error");
		memcpy(rrarray->void_ptr(),array_in,len*sizeof(int8_t));

	}

	static  void BytesToRRBaseArray( uint8_t* array_in, int32_t len,const boost::intrusive_ptr<RobotRaconteur::RRBaseArray>& rrarray)
	{
		if (rrarray->GetTypeID()!=DataTypes_uint8_t) throw InvalidArgumentException("RRArray error");
		if (rrarray->size()!=len) throw InvalidArgumentException("RRArray error");
		memcpy(rrarray->void_ptr(),array_in,len*sizeof(uint8_t));
	}


	static  void ShortsToRRBaseArray( int16_t* array_in, int32_t len,const boost::intrusive_ptr<RobotRaconteur::RRBaseArray>& rrarray)
	{
		if (rrarray->GetTypeID()!=DataTypes_int16_t && rrarray->GetTypeID()!=DataTypes_uint16_t) throw InvalidArgumentException("RRArray error");
		if (rrarray->size()!=len) throw InvalidArgumentException("RRArray error");
		memcpy(rrarray->void_ptr(),array_in,len*sizeof(int16_t));

	}

	static  void ShortsToRRBaseArray( uint16_t* array_in, int32_t len,const boost::intrusive_ptr<RobotRaconteur::RRBaseArray>& rrarray)
	{
		if (rrarray->GetTypeID()!=DataTypes_uint16_t) throw InvalidArgumentException("RRArray error");
		if (rrarray->size()!=len) throw InvalidArgumentException("RRArray error");
		memcpy(rrarray->void_ptr(),array_in,len*sizeof(uint16_t));

	}

	static void  IntsToRRBaseArray( int32_t* array_in, int32_t len,const boost::intrusive_ptr<RobotRaconteur::RRBaseArray>& rrarray)
	{
		if (rrarray->GetTypeID()!=DataTypes_int32_t && rrarray->GetTypeID()!=DataTypes_uint32_t) throw InvalidArgumentException("RRArray error");
		if (rrarray->size()!=len) throw InvalidArgumentException("RRArray error");
		memcpy(rrarray->void_ptr(),array_in,len*sizeof(int32_t));

	}

	static void  IntsToRRBaseArray( uint32_t* array_in, int32_t len,const boost::intrusive_ptr<RobotRaconteur::RRBaseArray>& rrarray)
	{
		if (rrarray->GetTypeID()!=DataTypes_uint32_t) throw InvalidArgumentException("RRArray error");
		if (rrarray->size()!=len) throw InvalidArgumentException("RRArray error");
		memcpy(rrarray->void_ptr(),array_in,len*sizeof(uint32_t));

	}

	static void LongsToRRBaseArray( int64_t* array_in, int32_t len,const boost::intrusive_ptr<RobotRaconteur::RRBaseArray>& rrarray)
	{
		if (rrarray->GetTypeID()!=DataTypes_int64_t && rrarray->GetTypeID()!=DataTypes_uint64_t) throw InvalidArgumentException("RRArray error");
		if (rrarray->size()!=len) throw InvalidArgumentException("RRArray error");
		memcpy(rrarray->void_ptr(),array_in,len*sizeof(int64_t));

	}

	static void LongsToRRBaseArray( uint64_t* array_in, int32_t len,const boost::intrusive_ptr<RobotRaconteur::RRBaseArray>& rrarray)
	{
		if (rrarray->GetTypeID()!=DataTypes_uint64_t) throw InvalidArgumentException("RRArray error");
		if (rrarray->size()!=len) throw InvalidArgumentException("RRArray error");
		memcpy(rrarray->void_ptr(),array_in,len*sizeof(uint64_t));

	}

	static void DoublesToComplexRRBaseArray(double* array_in, int32_t len,const boost::intrusive_ptr<RobotRaconteur::RRBaseArray>& rrarray)
	{
		if (rrarray->GetTypeID()!=DataTypes_cdouble_t) throw InvalidArgumentException("RRArray error");
		if (rrarray->size()!=len/2) throw InvalidArgumentException("RRArray error");
		memcpy(rrarray->void_ptr(),array_in,len*sizeof(double));
	}

	static void FloatsToComplexRRBaseArray(float* array_in, int32_t len,const boost::intrusive_ptr<RobotRaconteur::RRBaseArray>& rrarray)
	{
		if (rrarray->GetTypeID()!=DataTypes_csingle_t) throw InvalidArgumentException("RRArray error");
		if (rrarray->size()!=len/2) throw InvalidArgumentException("RRArray error");
		memcpy(rrarray->void_ptr(),array_in,len*sizeof(float));
	}

	static  void BytesToBoolRRBaseArray( int8_t* array_in, int32_t len,const boost::intrusive_ptr<RobotRaconteur::RRBaseArray>& rrarray)
	{
		if (rrarray->GetTypeID()!=DataTypes_bool_t) throw InvalidArgumentException("RRArray error");
		if (rrarray->size()!=len) throw InvalidArgumentException("RRArray error");
		memcpy((rr_bool*)rrarray->void_ptr(),array_in,len*sizeof(int8_t));
	}

	static  void BytesToBoolRRBaseArray( uint8_t* array_in, int32_t len,const boost::intrusive_ptr<RobotRaconteur::RRBaseArray>& rrarray)
	{
		if (rrarray->GetTypeID()!=DataTypes_bool_t) throw InvalidArgumentException("RRArray error");
		if (rrarray->size()!=len) throw InvalidArgumentException("RRArray error");
		memcpy((rr_bool*)rrarray->void_ptr(),array_in,len*sizeof(uint8_t));
	}


};



class rr_memcpy
{
public:
static void memcpy(void* destination, void* source, int64_t num)
{
	::memcpy(destination, source, boost::numeric_cast<size_t>(num));
}
};

SWIGINTERN std::vector< std::string > RobotRaconteur_TcpTransport_GetLocalAdapterIPAddresses(){
		std::vector<std::string> o;
		std::vector<boost::asio::ip::address> addr;
		RobotRaconteur::TcpTransport::GetLocalAdapterIPAddresses(addr);
		for (size_t i=0; i<addr.size(); i++)
		{
			o.push_back(boost::lexical_cast<std::string>(addr[i]));
		}
		return o;
	}

struct WallTimer_initstruct
{
	RobotRaconteur::AsyncTimerEventReturnDirector* handler;
	int32_t id;
};


SWIGINTERN RobotRaconteur::WallTimer *new_RobotRaconteur_WallTimer(boost::posix_time::time_duration const &period,bool oneshot,boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &node,WallTimer_initstruct init){
	boost::shared_ptr<AsyncTimerEventReturnDirector> sphandler(init.handler,boost::bind(&ReleaseDirector<AsyncTimerEventReturnDirector>,RR_BOOST_PLACEHOLDERS(_1),init.id));
	return new WallTimer(period,boost::bind(&TimerHandlerFunc,RR_BOOST_PLACEHOLDERS(_1),sphandler),oneshot,node);
}
SWIGINTERN boost::shared_ptr< RobotRaconteur::WrappedServiceStub > RobotRaconteur_WrappedServiceStub_FindObjRef__SWIG_0(RobotRaconteur::WrappedServiceStub *self,std::string const &n){
		return rr_cast<WrappedServiceStub>(self->FindObjRef(n));
	}
SWIGINTERN boost::shared_ptr< RobotRaconteur::WrappedServiceStub > RobotRaconteur_WrappedServiceStub_FindObjRef__SWIG_1(RobotRaconteur::WrappedServiceStub *self,std::string const &n,std::string const &i){
		return rr_cast<WrappedServiceStub>(self->FindObjRef(n,i));
	}
SWIGINTERN boost::shared_ptr< RobotRaconteur::WrappedServiceStub > RobotRaconteur_WrappedServiceStub_FindObjRefTyped__SWIG_0(RobotRaconteur::WrappedServiceStub *self,std::string const &n,std::string const &objecttype){
		return rr_cast<WrappedServiceStub>(self->FindObjRefTyped(n,objecttype));
	}
SWIGINTERN boost::shared_ptr< RobotRaconteur::WrappedServiceStub > RobotRaconteur_WrappedServiceStub_FindObjRefTyped__SWIG_1(RobotRaconteur::WrappedServiceStub *self,std::string const &n,std::string const &i,std::string const &objecttype){
		return rr_cast<WrappedServiceStub>(self->FindObjRefTyped(n,i,objecttype));
	}

class ServerServiceListenerDirector
{
public:

	int32_t objectheapid;

	ServerServiceListenerDirector()
	{
		objectheapid=0;
	}

	void OuterCallback(const boost::shared_ptr<ServerContext>& c,ServerServiceListenerEventType code,const boost::shared_ptr<void>& p)
	{
		if (code==ServerServiceListenerEventType_ClientConnected || code==ServerServiceListenerEventType_ClientDisconnected)
		{
			boost::shared_ptr<uint32_t> p2=boost::static_pointer_cast<uint32_t>(p);

			DIRECTOR_CALL2(Callback(code,*p2));
		}
		else
		{

			DIRECTOR_CALL2(Callback(code,0));
		}
	}
	virtual void Callback(int32_t code, uint32_t endpoint) {};



	virtual ~ServerServiceListenerDirector()
	{

	}

};

SWIGINTERN void RobotRaconteur_ServerContext_AddServerServiceListener(RobotRaconteur::ServerContext *self,ServerServiceListenerDirector *listener){
		boost::shared_ptr<ServerServiceListenerDirector> listener2=boost::shared_ptr<ServerServiceListenerDirector>(listener,boost::bind(&ReleaseDirector<ServerServiceListenerDirector>, RR_BOOST_PLACEHOLDERS(_1), listener->objectheapid));
		self->ServerServiceListener.connect(boost::bind(&ServerServiceListenerDirector::OuterCallback,listener2,RR_BOOST_PLACEHOLDERS(_1),RR_BOOST_PLACEHOLDERS(_2),RR_BOOST_PLACEHOLDERS(_3)));

	}
SWIGINTERN void RobotRaconteur_ServerContext_SetServiceAttributes(RobotRaconteur::ServerContext *self,boost::intrusive_ptr< RobotRaconteur::MessageElement > const &attributes){
		boost::intrusive_ptr<RRMap<std::string,RRValue> > mmap=rr_cast<RRMap<std::string,RRValue> >(RobotRaconteur::detail::packing::UnpackMapType<std::string,RRValue>(attributes->CastData<MessageElementNestedElementList >(),NULL));
		self->SetAttributes(mmap->GetStorageContainer());

	}
SWIGINTERN uint32_t RobotRaconteur_ServerEndpoint_GetCurrentEndpoint(){
			return ServerEndpoint::GetCurrentEndpoint()->GetLocalEndpoint();
		}
SWIGINTERN boost::shared_ptr< RobotRaconteur::AuthenticatedUser > RobotRaconteur_UserAuthenticator_AuthenticateUser(RobotRaconteur::UserAuthenticator *self,std::string const &username,boost::intrusive_ptr< RobotRaconteur::MessageElement > const &credentials,boost::shared_ptr< RobotRaconteur::ServerContext > const &context){
		if (!context) throw InvalidArgumentException("Context cannot be null");
		if (!credentials) throw InvalidArgumentException("Credentials cannot be null");
		boost::intrusive_ptr<RRMap<std::string,RRValue> > r=rr_cast<RRMap<std::string,RRValue> >(context->GetNode()->UnpackMapType<std::string,RRValue>(credentials->CastData<MessageElementNestedElementList >()));
		return self->AuthenticateUser(username,r->GetStorageContainer(),context,RR_SHARED_PTR<RobotRaconteur::ITransportConnection>());
	}
SWIGINTERN std::vector< RobotRaconteur::ServiceInfo2Wrapped > *new_std_vector_Sl_RobotRaconteur_ServiceInfo2Wrapped_Sg___SWIG_2(int capacity){
        std::vector< RobotRaconteur::ServiceInfo2Wrapped >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< RobotRaconteur::ServiceInfo2Wrapped >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN RobotRaconteur::ServiceInfo2Wrapped std_vector_Sl_RobotRaconteur_ServiceInfo2Wrapped_Sg__getitemcopy(std::vector< RobotRaconteur::ServiceInfo2Wrapped > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< RobotRaconteur::ServiceInfo2Wrapped >::value_type const &std_vector_Sl_RobotRaconteur_ServiceInfo2Wrapped_Sg__getitem(std::vector< RobotRaconteur::ServiceInfo2Wrapped > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServiceInfo2Wrapped_Sg__setitem(std::vector< RobotRaconteur::ServiceInfo2Wrapped > *self,int index,RobotRaconteur::ServiceInfo2Wrapped const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServiceInfo2Wrapped_Sg__AddRange(std::vector< RobotRaconteur::ServiceInfo2Wrapped > *self,std::vector< RobotRaconteur::ServiceInfo2Wrapped > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< RobotRaconteur::ServiceInfo2Wrapped > *std_vector_Sl_RobotRaconteur_ServiceInfo2Wrapped_Sg__GetRange(std::vector< RobotRaconteur::ServiceInfo2Wrapped > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< RobotRaconteur::ServiceInfo2Wrapped >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServiceInfo2Wrapped_Sg__Insert(std::vector< RobotRaconteur::ServiceInfo2Wrapped > *self,int index,RobotRaconteur::ServiceInfo2Wrapped const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServiceInfo2Wrapped_Sg__InsertRange(std::vector< RobotRaconteur::ServiceInfo2Wrapped > *self,int index,std::vector< RobotRaconteur::ServiceInfo2Wrapped > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServiceInfo2Wrapped_Sg__RemoveAt(std::vector< RobotRaconteur::ServiceInfo2Wrapped > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServiceInfo2Wrapped_Sg__RemoveRange(std::vector< RobotRaconteur::ServiceInfo2Wrapped > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< RobotRaconteur::ServiceInfo2Wrapped > *std_vector_Sl_RobotRaconteur_ServiceInfo2Wrapped_Sg__Repeat(RobotRaconteur::ServiceInfo2Wrapped const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< RobotRaconteur::ServiceInfo2Wrapped >(count, value);
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServiceInfo2Wrapped_Sg__Reverse__SWIG_0(std::vector< RobotRaconteur::ServiceInfo2Wrapped > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServiceInfo2Wrapped_Sg__Reverse__SWIG_1(std::vector< RobotRaconteur::ServiceInfo2Wrapped > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServiceInfo2Wrapped_Sg__SetRange(std::vector< RobotRaconteur::ServiceInfo2Wrapped > *self,int index,std::vector< RobotRaconteur::ServiceInfo2Wrapped > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::vector< RobotRaconteur::NodeInfo2 > *new_std_vector_Sl_RobotRaconteur_NodeInfo2_Sg___SWIG_2(int capacity){
        std::vector< RobotRaconteur::NodeInfo2 >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< RobotRaconteur::NodeInfo2 >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN RobotRaconteur::NodeInfo2 std_vector_Sl_RobotRaconteur_NodeInfo2_Sg__getitemcopy(std::vector< RobotRaconteur::NodeInfo2 > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< RobotRaconteur::NodeInfo2 >::value_type const &std_vector_Sl_RobotRaconteur_NodeInfo2_Sg__getitem(std::vector< RobotRaconteur::NodeInfo2 > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_NodeInfo2_Sg__setitem(std::vector< RobotRaconteur::NodeInfo2 > *self,int index,RobotRaconteur::NodeInfo2 const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_NodeInfo2_Sg__AddRange(std::vector< RobotRaconteur::NodeInfo2 > *self,std::vector< RobotRaconteur::NodeInfo2 > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< RobotRaconteur::NodeInfo2 > *std_vector_Sl_RobotRaconteur_NodeInfo2_Sg__GetRange(std::vector< RobotRaconteur::NodeInfo2 > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< RobotRaconteur::NodeInfo2 >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_NodeInfo2_Sg__Insert(std::vector< RobotRaconteur::NodeInfo2 > *self,int index,RobotRaconteur::NodeInfo2 const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_NodeInfo2_Sg__InsertRange(std::vector< RobotRaconteur::NodeInfo2 > *self,int index,std::vector< RobotRaconteur::NodeInfo2 > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_NodeInfo2_Sg__RemoveAt(std::vector< RobotRaconteur::NodeInfo2 > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_NodeInfo2_Sg__RemoveRange(std::vector< RobotRaconteur::NodeInfo2 > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< RobotRaconteur::NodeInfo2 > *std_vector_Sl_RobotRaconteur_NodeInfo2_Sg__Repeat(RobotRaconteur::NodeInfo2 const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< RobotRaconteur::NodeInfo2 >(count, value);
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_NodeInfo2_Sg__Reverse__SWIG_0(std::vector< RobotRaconteur::NodeInfo2 > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_NodeInfo2_Sg__Reverse__SWIG_1(std::vector< RobotRaconteur::NodeInfo2 > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_NodeInfo2_Sg__SetRange(std::vector< RobotRaconteur::NodeInfo2 > *self,int index,std::vector< RobotRaconteur::NodeInfo2 > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::mapped_type const &std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_RobotRaconteur_ServiceInfo2Wrapped_Sg__getitem(std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *self,std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::key_type const &key){
        std::map< RobotRaconteur::ServiceSubscriptionClientID, RobotRaconteur::ServiceInfo2Wrapped, std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator iter = self->find(key);
        if (iter != self->end())
          return iter->second;
        else
          throw std::out_of_range("key not found");
      }
SWIGINTERN void std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_RobotRaconteur_ServiceInfo2Wrapped_Sg__setitem(std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *self,std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::key_type const &key,std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::mapped_type const &x){
        (*self)[key] = x;
      }
SWIGINTERN bool std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_RobotRaconteur_ServiceInfo2Wrapped_Sg__ContainsKey(std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *self,std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::key_type const &key){
        std::map< RobotRaconteur::ServiceSubscriptionClientID, RobotRaconteur::ServiceInfo2Wrapped, std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator iter = self->find(key);
        return iter != self->end();
      }
SWIGINTERN void std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_RobotRaconteur_ServiceInfo2Wrapped_Sg__Add(std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *self,std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::key_type const &key,std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::mapped_type const &value){
        std::map< RobotRaconteur::ServiceSubscriptionClientID, RobotRaconteur::ServiceInfo2Wrapped, std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator iter = self->find(key);
        if (iter != self->end())
          throw std::out_of_range("key already exists");
        self->insert(std::pair< RobotRaconteur::ServiceSubscriptionClientID, RobotRaconteur::ServiceInfo2Wrapped >(key, value));
      }
SWIGINTERN bool std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_RobotRaconteur_ServiceInfo2Wrapped_Sg__Remove(std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *self,std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::key_type const &key){
        std::map< RobotRaconteur::ServiceSubscriptionClientID, RobotRaconteur::ServiceInfo2Wrapped, std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator iter = self->find(key);
        if (iter != self->end()) {
          self->erase(iter);
          return true;
        }
        return false;
      }
SWIGINTERN std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped,std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator *std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_RobotRaconteur_ServiceInfo2Wrapped_Sg__create_iterator_begin(std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *self){
        return new std::map< RobotRaconteur::ServiceSubscriptionClientID, RobotRaconteur::ServiceInfo2Wrapped, std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator(self->begin());
      }
SWIGINTERN std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::key_type const &std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_RobotRaconteur_ServiceInfo2Wrapped_Sg__get_next_key(std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *self,std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped,std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator *swigiterator){
        std::map< RobotRaconteur::ServiceSubscriptionClientID, RobotRaconteur::ServiceInfo2Wrapped, std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator iter = *swigiterator;
        (*swigiterator)++;
        return (*iter).first;
      }
SWIGINTERN void std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_RobotRaconteur_ServiceInfo2Wrapped_Sg__destroy_iterator(std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *self,std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped,std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator *swigiterator){
        delete swigiterator;
      }
SWIGINTERN std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::mapped_type const &std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceStub_Sg__Sg__getitem(std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *self,std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::key_type const &key){
        std::map< RobotRaconteur::ServiceSubscriptionClientID, boost::shared_ptr< RobotRaconteur::WrappedServiceStub >, std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator iter = self->find(key);
        if (iter != self->end())
          return iter->second;
        else
          throw std::out_of_range("key not found");
      }
SWIGINTERN void std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceStub_Sg__Sg__setitem(std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *self,std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::key_type const &key,std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::mapped_type const &x){
        (*self)[key] = x;
      }
SWIGINTERN bool std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceStub_Sg__Sg__ContainsKey(std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *self,std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::key_type const &key){
        std::map< RobotRaconteur::ServiceSubscriptionClientID, boost::shared_ptr< RobotRaconteur::WrappedServiceStub >, std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator iter = self->find(key);
        return iter != self->end();
      }
SWIGINTERN void std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceStub_Sg__Sg__Add(std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *self,std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::key_type const &key,std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::mapped_type const &value){
        std::map< RobotRaconteur::ServiceSubscriptionClientID, boost::shared_ptr< RobotRaconteur::WrappedServiceStub >, std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator iter = self->find(key);
        if (iter != self->end())
          throw std::out_of_range("key already exists");
        self->insert(std::pair< RobotRaconteur::ServiceSubscriptionClientID, boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >(key, value));
      }
SWIGINTERN bool std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceStub_Sg__Sg__Remove(std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *self,std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::key_type const &key){
        std::map< RobotRaconteur::ServiceSubscriptionClientID, boost::shared_ptr< RobotRaconteur::WrappedServiceStub >, std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator iter = self->find(key);
        if (iter != self->end()) {
          self->erase(iter);
          return true;
        }
        return false;
      }
SWIGINTERN std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub >,std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator *std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceStub_Sg__Sg__create_iterator_begin(std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *self){
        return new std::map< RobotRaconteur::ServiceSubscriptionClientID, boost::shared_ptr< RobotRaconteur::WrappedServiceStub >, std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator(self->begin());
      }
SWIGINTERN std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::key_type const &std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceStub_Sg__Sg__get_next_key(std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *self,std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub >,std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator *swigiterator){
        std::map< RobotRaconteur::ServiceSubscriptionClientID, boost::shared_ptr< RobotRaconteur::WrappedServiceStub >, std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator iter = *swigiterator;
        (*swigiterator)++;
        return (*iter).first;
      }
SWIGINTERN void std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceStub_Sg__Sg__destroy_iterator(std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *self,std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub >,std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator *swigiterator){
        delete swigiterator;
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *new_std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Sg__Sg___SWIG_2(int capacity){
        std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Sg__Sg__getitemcopy(std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > >::value_type const &std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Sg__Sg__getitem(std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Sg__Sg__setitem(std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *self,int index,boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Sg__Sg__AddRange(std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *self,std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Sg__Sg__GetRange(std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Sg__Sg__Insert(std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *self,int index,boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Sg__Sg__InsertRange(std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *self,int index,std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Sg__Sg__RemoveAt(std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Sg__Sg__RemoveRange(std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Sg__Sg__Repeat(boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > >(count, value);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Sg__Sg__Reverse__SWIG_0(std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Sg__Sg__Reverse__SWIG_1(std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Sg__Sg__SetRange(std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *self,int index,std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::vector< RobotRaconteur::ServiceSubscriptionClientID > *new_std_vector_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sg___SWIG_2(int capacity){
        std::vector< RobotRaconteur::ServiceSubscriptionClientID >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< RobotRaconteur::ServiceSubscriptionClientID >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN RobotRaconteur::ServiceSubscriptionClientID std_vector_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sg__getitemcopy(std::vector< RobotRaconteur::ServiceSubscriptionClientID > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< RobotRaconteur::ServiceSubscriptionClientID >::value_type const &std_vector_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sg__getitem(std::vector< RobotRaconteur::ServiceSubscriptionClientID > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sg__setitem(std::vector< RobotRaconteur::ServiceSubscriptionClientID > *self,int index,RobotRaconteur::ServiceSubscriptionClientID const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sg__AddRange(std::vector< RobotRaconteur::ServiceSubscriptionClientID > *self,std::vector< RobotRaconteur::ServiceSubscriptionClientID > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< RobotRaconteur::ServiceSubscriptionClientID > *std_vector_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sg__GetRange(std::vector< RobotRaconteur::ServiceSubscriptionClientID > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< RobotRaconteur::ServiceSubscriptionClientID >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sg__Insert(std::vector< RobotRaconteur::ServiceSubscriptionClientID > *self,int index,RobotRaconteur::ServiceSubscriptionClientID const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sg__InsertRange(std::vector< RobotRaconteur::ServiceSubscriptionClientID > *self,int index,std::vector< RobotRaconteur::ServiceSubscriptionClientID > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sg__RemoveAt(std::vector< RobotRaconteur::ServiceSubscriptionClientID > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sg__RemoveRange(std::vector< RobotRaconteur::ServiceSubscriptionClientID > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< RobotRaconteur::ServiceSubscriptionClientID > *std_vector_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sg__Repeat(RobotRaconteur::ServiceSubscriptionClientID const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< RobotRaconteur::ServiceSubscriptionClientID >(count, value);
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sg__Reverse__SWIG_0(std::vector< RobotRaconteur::ServiceSubscriptionClientID > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sg__Reverse__SWIG_1(std::vector< RobotRaconteur::ServiceSubscriptionClientID > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sg__SetRange(std::vector< RobotRaconteur::ServiceSubscriptionClientID > *self,int index,std::vector< RobotRaconteur::ServiceSubscriptionClientID > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *new_std_vector_Sl_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Sg___SWIG_2(int capacity){
        std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN RobotRaconteur::WrappedServiceSubscriptionManagerDetails std_vector_Sl_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Sg__getitemcopy(std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails >::value_type const &std_vector_Sl_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Sg__getitem(std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Sg__setitem(std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *self,int index,RobotRaconteur::WrappedServiceSubscriptionManagerDetails const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Sg__AddRange(std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *self,std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *std_vector_Sl_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Sg__GetRange(std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Sg__Insert(std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *self,int index,RobotRaconteur::WrappedServiceSubscriptionManagerDetails const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Sg__InsertRange(std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *self,int index,std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Sg__RemoveAt(std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Sg__RemoveRange(std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *std_vector_Sl_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Sg__Repeat(RobotRaconteur::WrappedServiceSubscriptionManagerDetails const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails >(count, value);
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Sg__Reverse__SWIG_0(std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Sg__Reverse__SWIG_1(std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Sg__SetRange(std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *self,int index,std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *new_std_vector_Sl_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg___SWIG_2(int capacity){
        std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN RobotRaconteur::ServiceSubscriptionFilterAttribute std_vector_Sl_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__getitemcopy(std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute >::value_type const &std_vector_Sl_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__getitem(std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__setitem(std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *self,int index,RobotRaconteur::ServiceSubscriptionFilterAttribute const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__AddRange(std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *self,std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *std_vector_Sl_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__GetRange(std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__Insert(std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *self,int index,RobotRaconteur::ServiceSubscriptionFilterAttribute const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__InsertRange(std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *self,int index,std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__RemoveAt(std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__RemoveRange(std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *std_vector_Sl_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__Repeat(RobotRaconteur::ServiceSubscriptionFilterAttribute const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute >(count, value);
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__Reverse__SWIG_0(std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__Reverse__SWIG_1(std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__SetRange(std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *self,int index,std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >::mapped_type const &std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__getitem(std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *self,std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >::key_type const &key){
        std::map< std::string, RobotRaconteur::ServiceSubscriptionFilterAttribute, std::less< std::string > >::iterator iter = self->find(key);
        if (iter != self->end())
          return iter->second;
        else
          throw std::out_of_range("key not found");
      }
SWIGINTERN void std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__setitem(std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *self,std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >::key_type const &key,std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >::mapped_type const &x){
        (*self)[key] = x;
      }
SWIGINTERN bool std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__ContainsKey(std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *self,std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >::key_type const &key){
        std::map< std::string, RobotRaconteur::ServiceSubscriptionFilterAttribute, std::less< std::string > >::iterator iter = self->find(key);
        return iter != self->end();
      }
SWIGINTERN void std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__Add(std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *self,std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >::key_type const &key,std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >::mapped_type const &value){
        std::map< std::string, RobotRaconteur::ServiceSubscriptionFilterAttribute, std::less< std::string > >::iterator iter = self->find(key);
        if (iter != self->end())
          throw std::out_of_range("key already exists");
        self->insert(std::pair< std::string, RobotRaconteur::ServiceSubscriptionFilterAttribute >(key, value));
      }
SWIGINTERN bool std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__Remove(std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *self,std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >::key_type const &key){
        std::map< std::string, RobotRaconteur::ServiceSubscriptionFilterAttribute, std::less< std::string > >::iterator iter = self->find(key);
        if (iter != self->end()) {
          self->erase(iter);
          return true;
        }
        return false;
      }
SWIGINTERN std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute,std::less< std::string > >::iterator *std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__create_iterator_begin(std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *self){
        return new std::map< std::string, RobotRaconteur::ServiceSubscriptionFilterAttribute, std::less< std::string > >::iterator(self->begin());
      }
SWIGINTERN std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >::key_type const &std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__get_next_key(std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *self,std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute,std::less< std::string > >::iterator *swigiterator){
        std::map< std::string, RobotRaconteur::ServiceSubscriptionFilterAttribute, std::less< std::string > >::iterator iter = *swigiterator;
        (*swigiterator)++;
        return (*iter).first;
      }
SWIGINTERN void std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__destroy_iterator(std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *self,std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute,std::less< std::string > >::iterator *swigiterator){
        delete swigiterator;
      }
SWIGINTERN std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >::mapped_type const &std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttributeGroup_Sg__getitem(std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *self,std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >::key_type const &key){
        std::map< std::string, RobotRaconteur::ServiceSubscriptionFilterAttributeGroup, std::less< std::string > >::iterator iter = self->find(key);
        if (iter != self->end())
          return iter->second;
        else
          throw std::out_of_range("key not found");
      }
SWIGINTERN void std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttributeGroup_Sg__setitem(std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *self,std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >::key_type const &key,std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >::mapped_type const &x){
        (*self)[key] = x;
      }
SWIGINTERN bool std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttributeGroup_Sg__ContainsKey(std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *self,std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >::key_type const &key){
        std::map< std::string, RobotRaconteur::ServiceSubscriptionFilterAttributeGroup, std::less< std::string > >::iterator iter = self->find(key);
        return iter != self->end();
      }
SWIGINTERN void std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttributeGroup_Sg__Add(std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *self,std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >::key_type const &key,std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >::mapped_type const &value){
        std::map< std::string, RobotRaconteur::ServiceSubscriptionFilterAttributeGroup, std::less< std::string > >::iterator iter = self->find(key);
        if (iter != self->end())
          throw std::out_of_range("key already exists");
        self->insert(std::pair< std::string, RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >(key, value));
      }
SWIGINTERN bool std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttributeGroup_Sg__Remove(std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *self,std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >::key_type const &key){
        std::map< std::string, RobotRaconteur::ServiceSubscriptionFilterAttributeGroup, std::less< std::string > >::iterator iter = self->find(key);
        if (iter != self->end()) {
          self->erase(iter);
          return true;
        }
        return false;
      }
SWIGINTERN std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup,std::less< std::string > >::iterator *std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttributeGroup_Sg__create_iterator_begin(std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *self){
        return new std::map< std::string, RobotRaconteur::ServiceSubscriptionFilterAttributeGroup, std::less< std::string > >::iterator(self->begin());
      }
SWIGINTERN std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >::key_type const &std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttributeGroup_Sg__get_next_key(std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *self,std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup,std::less< std::string > >::iterator *swigiterator){
        std::map< std::string, RobotRaconteur::ServiceSubscriptionFilterAttributeGroup, std::less< std::string > >::iterator iter = *swigiterator;
        (*swigiterator)++;
        return (*iter).first;
      }
SWIGINTERN void std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttributeGroup_Sg__destroy_iterator(std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *self,std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup,std::less< std::string > >::iterator *swigiterator){
        delete swigiterator;
      }
SWIGINTERN boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > RobotRaconteur_RRLogRecord_GetNode(RobotRaconteur::RRLogRecord *self){
                return self->Node.lock();
            }
SWIGINTERN void RobotRaconteur_RRLogRecord_SetNode(RobotRaconteur::RRLogRecord *self,boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &node){
                self->Node = node;
            }
SWIGINTERN std::string RobotRaconteur_RRLogRecord_ToString(RobotRaconteur::RRLogRecord *self){
                std::stringstream ss;
                ss << *self;
                return ss.str();
            }

class ClientServiceListenerDirector
{
public:

	int32_t objectheapid;

	ClientServiceListenerDirector()
	{
		objectheapid=0;
	}

	void OuterCallback(const boost::shared_ptr<RobotRaconteur::ClientContext>& c,ClientServiceListenerEventType code,const boost::shared_ptr<void>& p)
	{
		if (code == ClientServiceListenerEventType_ServicePathReleased)
		{
			std::string p1 = *RR_STATIC_POINTER_CAST<std::string>(p);
			DIRECTOR_CALL2(Callback2(code,p1));
		}
		else
		{
			DIRECTOR_CALL2(Callback(code));
		}
	}
	virtual void Callback(int32_t code) {};
	virtual void Callback2(int32_t code, const std::string& p) {};

	virtual ~ClientServiceListenerDirector()
	{

	}

};

SWIGINTERN boost::shared_ptr< RobotRaconteur::WrappedServiceStub > RobotRaconteur_RobotRaconteurNode_ConnectService__SWIG_0(RobotRaconteur::RobotRaconteurNode *self,std::string const &url,std::string const &username="",boost::intrusive_ptr< RobotRaconteur::MessageElementData > credentials=boost::intrusive_ptr< RobotRaconteur::MessageElementData >(),ClientServiceListenerDirector *listener=0,std::string const &objecttype=""){
		boost::shared_ptr<ClientServiceListenerDirector> listenerptr;
		if (listener)
		{
			listenerptr=boost::shared_ptr<ClientServiceListenerDirector>(listener,boost::bind(&ReleaseDirector<ClientServiceListenerDirector>,RR_BOOST_PLACEHOLDERS(_1),listener->objectheapid));
		}

		boost::intrusive_ptr<RRMap<std::string,RRValue> > credentials2;
		if (credentials) credentials2=rr_cast<RRMap<std::string,RRValue> >(self->UnpackMapType<std::string,RRValue>(rr_cast<MessageElementNestedElementList>(credentials)));
		boost::shared_ptr<WrappedServiceStub> stub;
		if (listener==0)
		{
			stub=rr_cast<WrappedServiceStub>(self->ConnectService(url,username,credentials2,RR_NULL_FN,objecttype));
		}
		else
		{

			stub=rr_cast<WrappedServiceStub>(self->ConnectService(url,username,credentials2,boost::bind(&ClientServiceListenerDirector::OuterCallback,listenerptr,RR_BOOST_PLACEHOLDERS(_1),RR_BOOST_PLACEHOLDERS(_2),RR_BOOST_PLACEHOLDERS(_3)),objecttype));
		}

		return stub;

	}
SWIGINTERN boost::shared_ptr< RobotRaconteur::WrappedServiceStub > RobotRaconteur_RobotRaconteurNode_ConnectService__SWIG_5(RobotRaconteur::RobotRaconteurNode *self,std::vector< std::string > const &url,std::string const &username="",boost::intrusive_ptr< RobotRaconteur::MessageElementData > credentials=boost::intrusive_ptr< RobotRaconteur::MessageElementData >(),ClientServiceListenerDirector *listener=0,std::string const &objecttype=""){

		boost::shared_ptr<ClientServiceListenerDirector> listenerptr;
		if (listener)
		{
			listenerptr=boost::shared_ptr<ClientServiceListenerDirector>(listener,boost::bind(&ReleaseDirector<ClientServiceListenerDirector>,RR_BOOST_PLACEHOLDERS(_1),listener->objectheapid));
		}

		boost::intrusive_ptr<RRMap<std::string,RRValue> > credentials2;
		if (credentials) credentials2=rr_cast<RRMap<std::string,RRValue> >(self->UnpackMapType<std::string,RRValue>(rr_cast<MessageElementNestedElementList >(credentials)));
		boost::shared_ptr<WrappedServiceStub> stub;
		if (listener==0)
		{
			stub=rr_cast<WrappedServiceStub>(self->ConnectService(url,username,credentials2,RR_NULL_FN,objecttype));
		}
		else
		{

			stub=rr_cast<WrappedServiceStub>(self->ConnectService(url,username,credentials2,boost::bind(&ClientServiceListenerDirector::OuterCallback,listenerptr,RR_BOOST_PLACEHOLDERS(_1),RR_BOOST_PLACEHOLDERS(_2),RR_BOOST_PLACEHOLDERS(_3)),objecttype));
		}
		return stub;

	}
SWIGINTERN void RobotRaconteur_RobotRaconteurNode_AsyncConnectService__SWIG_0(RobotRaconteur::RobotRaconteurNode *self,std::string const &url,std::string const &username,boost::intrusive_ptr< RobotRaconteur::MessageElementData > const &credentials,ClientServiceListenerDirector *listener,std::string const &objecttype,int32_t timeout,RobotRaconteur::AsyncStubReturnDirector *handler,int32_t id){

		boost::shared_ptr<AsyncStubReturnDirector> sphandler(handler,boost::bind(&ReleaseDirector<AsyncStubReturnDirector>,RR_BOOST_PLACEHOLDERS(_1),id));

		boost::intrusive_ptr<RRMap<std::string,RRValue> > credentials2;
		if (credentials) credentials2=rr_cast<RRMap<std::string,RRValue> >(self->UnpackMapType<std::string,RRValue>(rr_cast<MessageElementNestedElementList >(credentials)));

		if (listener==0)
		{
			self->AsyncConnectService(url,username,credentials2,RR_NULL_FN,objecttype,boost::bind(&AsyncStubReturn_handler,RR_BOOST_PLACEHOLDERS(_1),RR_BOOST_PLACEHOLDERS(_2),sphandler),timeout);
		}
		else
		{
			boost::shared_ptr<ClientServiceListenerDirector> listenerptr=boost::shared_ptr<ClientServiceListenerDirector>(listener);
			self->AsyncConnectService(url,username,credentials2,boost::bind(&ClientServiceListenerDirector::OuterCallback,listenerptr,RR_BOOST_PLACEHOLDERS(_1),RR_BOOST_PLACEHOLDERS(_2),RR_BOOST_PLACEHOLDERS(_3)),objecttype,boost::bind(&AsyncStubReturn_handler,RR_BOOST_PLACEHOLDERS(_1),RR_BOOST_PLACEHOLDERS(_2),sphandler),timeout);
		}
	}
SWIGINTERN void RobotRaconteur_RobotRaconteurNode_AsyncConnectService__SWIG_1(RobotRaconteur::RobotRaconteurNode *self,std::vector< std::string > const &url,std::string const &username,boost::intrusive_ptr< RobotRaconteur::MessageElementData > const &credentials,ClientServiceListenerDirector *listener,std::string const &objecttype,int32_t timeout,RobotRaconteur::AsyncStubReturnDirector *handler,int32_t id){

		boost::shared_ptr<AsyncStubReturnDirector> sphandler(handler,boost::bind(&ReleaseDirector<AsyncStubReturnDirector>,RR_BOOST_PLACEHOLDERS(_1),id));

		boost::intrusive_ptr<RRMap<std::string,RRValue> > credentials2;
		if (credentials) credentials2=rr_cast<RRMap<std::string,RRValue> >(self->UnpackMapType<std::string,RRValue>(rr_cast<MessageElementNestedElementList >(credentials)));

		if (listener==0)
		{
			self->AsyncConnectService(url,username,credentials2,RR_NULL_FN,objecttype,boost::bind(&AsyncStubReturn_handler,RR_BOOST_PLACEHOLDERS(_1),RR_BOOST_PLACEHOLDERS(_2),sphandler),timeout);
		}
		else
		{
			boost::shared_ptr<ClientServiceListenerDirector> listenerptr=boost::shared_ptr<ClientServiceListenerDirector>(listener);
			self->AsyncConnectService(url,username,credentials2,boost::bind(&ClientServiceListenerDirector::OuterCallback,listenerptr,RR_BOOST_PLACEHOLDERS(_1),RR_BOOST_PLACEHOLDERS(_2),RR_BOOST_PLACEHOLDERS(_3)),objecttype,boost::bind(&AsyncStubReturn_handler,RR_BOOST_PLACEHOLDERS(_1),RR_BOOST_PLACEHOLDERS(_2),sphandler),timeout);
		}
	}
SWIGINTERN void RobotRaconteur_RobotRaconteurNode_DisconnectService(RobotRaconteur::RobotRaconteurNode *self,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &obj){
		self->DisconnectService(obj);
	}
SWIGINTERN void RobotRaconteur_RobotRaconteurNode_AsyncDisconnectService(RobotRaconteur::RobotRaconteurNode *self,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &obj,RobotRaconteur::AsyncVoidNoErrReturnDirector *handler,int32_t id){
		boost::shared_ptr<AsyncVoidNoErrReturnDirector> sphandler(handler,boost::bind(&ReleaseDirector<AsyncVoidNoErrReturnDirector>,RR_BOOST_PLACEHOLDERS(_1),id));
		self->AsyncDisconnectService(obj,boost::bind(&AsyncVoidNoErrReturn_handler,sphandler));
	}
SWIGINTERN void RobotRaconteur_RobotRaconteurNode_RegisterServiceType(RobotRaconteur::RobotRaconteurNode *self,boost::shared_ptr< RobotRaconteur::ServiceDefinition > const &def){











		self->RegisterServiceType(boost::make_shared<WrappedServiceFactory>(def));
	}
SWIGINTERN void RobotRaconteur_RobotRaconteurNode_RegisterServiceTypes(RobotRaconteur::RobotRaconteurNode *self,std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > const &defs){














		BOOST_FOREACH(const boost::shared_ptr<RobotRaconteur::ServiceDefinition>& def, defs)
		{
			self->RegisterServiceType(boost::make_shared<WrappedServiceFactory>(def));
		}
	}
SWIGINTERN boost::shared_ptr< RobotRaconteur::ServiceDefinition > RobotRaconteur_RobotRaconteurNode_GetServiceType(RobotRaconteur::RobotRaconteurNode *self,std::string const &servicename){
		return rr_cast<WrappedServiceFactory>(self->GetServiceType(servicename))->ServiceDef();
	}
SWIGINTERN boost::shared_ptr< RobotRaconteur::ServiceDefinition > RobotRaconteur_RobotRaconteurNode_GetPulledServiceType(RobotRaconteur::RobotRaconteurNode *self,boost::shared_ptr< RobotRaconteur::RRObject > const &obj,std::string const &servicename){
		return rr_cast<WrappedServiceFactory>(self->GetPulledServiceType(obj,servicename))->ServiceDef();
	}
SWIGINTERN std::string RobotRaconteur_RobotRaconteurNode_RequestObjectLock(RobotRaconteur::RobotRaconteurNode *self,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &obj,RobotRaconteur::RobotRaconteurObjectLockFlags flags){
		return self->RequestObjectLock(obj,flags);
	}
SWIGINTERN std::string RobotRaconteur_RobotRaconteurNode_ReleaseObjectLock(RobotRaconteur::RobotRaconteurNode *self,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &obj){
		return self->ReleaseObjectLock(obj);
	}
SWIGINTERN void RobotRaconteur_RobotRaconteurNode_MonitorEnter__SWIG_0(RobotRaconteur::RobotRaconteurNode *self,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &obj,int32_t timeout=-1){
		self->MonitorEnter(obj,timeout);
	}
SWIGINTERN void RobotRaconteur_RobotRaconteurNode_MonitorExit(RobotRaconteur::RobotRaconteurNode *self,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &obj){
		self->MonitorExit(obj);
	}
SWIGINTERN void RobotRaconteur_RobotRaconteurNode_AsyncRequestObjectLock(RobotRaconteur::RobotRaconteurNode *self,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &obj,RobotRaconteur::RobotRaconteurObjectLockFlags flags,int32_t timeout,RobotRaconteur::AsyncStringReturnDirector *handler,int32_t id){
		boost::shared_ptr<AsyncStringReturnDirector> sphandler(handler,boost::bind(&ReleaseDirector<AsyncStringReturnDirector>,RR_BOOST_PLACEHOLDERS(_1),id));
		return self->AsyncRequestObjectLock(obj,flags,boost::bind(&AsyncStringReturn_handler,RR_BOOST_PLACEHOLDERS(_1),RR_BOOST_PLACEHOLDERS(_2),sphandler),timeout);
	}
SWIGINTERN void RobotRaconteur_RobotRaconteurNode_AsyncReleaseObjectLock(RobotRaconteur::RobotRaconteurNode *self,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &obj,int32_t timeout,RobotRaconteur::AsyncStringReturnDirector *handler,int32_t id){
		boost::shared_ptr<AsyncStringReturnDirector> sphandler(handler,boost::bind(&ReleaseDirector<AsyncStringReturnDirector>,RR_BOOST_PLACEHOLDERS(_1),id));
		return self->AsyncReleaseObjectLock(obj,boost::bind(&AsyncStringReturn_handler,RR_BOOST_PLACEHOLDERS(_1),RR_BOOST_PLACEHOLDERS(_2),sphandler),timeout);
	}
SWIGINTERN boost::intrusive_ptr< RobotRaconteur::MessageElement > RobotRaconteur_RobotRaconteurNode_GetServiceAttributes(RobotRaconteur::RobotRaconteurNode *self,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &obj){
			boost::intrusive_ptr<RRMap<std::string,RRValue> > map=AllocateEmptyRRMap<std::string,RRValue>();
			map->GetStorageContainer()=self->GetServiceAttributes(obj);
			boost::intrusive_ptr<MessageElementNestedElementList > mmap=self->PackMapType<std::string,RRValue>(map);
			return CreateMessageElement("value",mmap);
		}
SWIGINTERN RobotRaconteur::NodeID RobotRaconteur_RobotRaconteurNode_GetServiceNodeID(RobotRaconteur::RobotRaconteurNode *self,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &obj){
		return self->GetServiceNodeID(obj);
	}
SWIGINTERN std::string RobotRaconteur_RobotRaconteurNode_GetServiceNodeName(RobotRaconteur::RobotRaconteurNode *self,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &obj){
		return self->GetServiceNodeName(obj);
	}
SWIGINTERN std::string RobotRaconteur_RobotRaconteurNode_GetServiceName(RobotRaconteur::RobotRaconteurNode *self,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &obj){
		return self->GetServiceName(obj);
	}
SWIGINTERN std::string RobotRaconteur_RobotRaconteurNode_GetObjectServicePath(RobotRaconteur::RobotRaconteurNode *self,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &obj){
		return self->GetObjectServicePath(obj);
	}
SWIGINTERN std::string RobotRaconteur_RobotRaconteurNode_GetObjectType(RobotRaconteur::RobotRaconteurNode *self,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &obj){
		return self->GetObjectType(obj);
	}
SWIGINTERN void RobotRaconteur_RobotRaconteurNode_AsyncFindObjectType__SWIG_0(RobotRaconteur::RobotRaconteurNode *self,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &obj,std::string const &n,int32_t timeout,RobotRaconteur::AsyncStringReturnDirector *handler,int32_t id){
		boost::shared_ptr<AsyncStringReturnDirector> sphandler(handler,boost::bind(&ReleaseDirector<AsyncStringReturnDirector>,RR_BOOST_PLACEHOLDERS(_1),id));
		return self->AsyncFindObjectType(obj,n,boost::bind(&AsyncStringReturn_handler,RR_BOOST_PLACEHOLDERS(_1),RR_BOOST_PLACEHOLDERS(_2),sphandler),timeout);
	}
SWIGINTERN void RobotRaconteur_RobotRaconteurNode_AsyncFindObjectType__SWIG_1(RobotRaconteur::RobotRaconteurNode *self,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &obj,std::string const &n,std::string const &i,int32_t timeout,RobotRaconteur::AsyncStringReturnDirector *handler,int32_t id){
		boost::shared_ptr<AsyncStringReturnDirector> sphandler(handler,boost::bind(&ReleaseDirector<AsyncStringReturnDirector>,RR_BOOST_PLACEHOLDERS(_1),id));
		return self->AsyncFindObjectType(obj,n,i,boost::bind(&AsyncStringReturn_handler,RR_BOOST_PLACEHOLDERS(_1),RR_BOOST_PLACEHOLDERS(_2),sphandler),timeout);
	}
SWIGINTERN void RobotRaconteur_RobotRaconteurNode_SetExceptionHandler(RobotRaconteur::RobotRaconteurNode *self,RobotRaconteur::AsyncVoidReturnDirector *handler,int32_t id){
		RR_SHARED_PTR<AsyncVoidReturnDirector> sphandler(handler,boost::bind(&ReleaseDirector<AsyncVoidReturnDirector>,RR_BOOST_PLACEHOLDERS(_1),id));
		self->SetExceptionHandler(boost::bind(&WrappedExceptionHandler,RR_BOOST_PLACEHOLDERS(_1),sphandler));
	}
SWIGINTERN void RobotRaconteur_RobotRaconteurNode_ClearExceptionHandler(RobotRaconteur::RobotRaconteurNode *self){
		self->SetExceptionHandler(RR_NULL_FN);
	}
SWIGINTERN boost::shared_ptr< RobotRaconteur::Timer > RobotRaconteur_RobotRaconteurNode_CreateTimer(RobotRaconteur::RobotRaconteurNode *self,boost::posix_time::time_duration const &period,bool oneshot,RobotRaconteur::AsyncTimerEventReturnDirector *handler,int32_t id){
		boost::shared_ptr<AsyncTimerEventReturnDirector> sphandler(handler,boost::bind(&ReleaseDirector<AsyncTimerEventReturnDirector>,RR_BOOST_PLACEHOLDERS(_1),id));
		return self->CreateTimer(period,boost::bind(&TimerHandlerFunc,RR_BOOST_PLACEHOLDERS(_1),sphandler),oneshot);
	}
SWIGINTERN void RobotRaconteur_RobotRaconteurNode_PostToThreadPool(RobotRaconteur::RobotRaconteurNode *self,RobotRaconteur::AsyncVoidNoErrReturnDirector *handler,int32_t id){
		boost::shared_ptr<AsyncVoidNoErrReturnDirector> sphandler(handler,boost::bind(&ReleaseDirector<AsyncVoidNoErrReturnDirector>,RR_BOOST_PLACEHOLDERS(_1),id));
		self->GetThreadPool()->Post(boost::bind(&AsyncVoidNoErrReturn_handler,sphandler));
	}
SWIGINTERN RobotRaconteur::RobotRaconteurNodeSetup *new_RobotRaconteur_RobotRaconteurNodeSetup__SWIG_0(boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &node,std::string const &node_name,uint16_t tcp_port,uint32_t flags){
				std::vector<RR_SHARED_PTR<ServiceFactory> > s;
				RobotRaconteurNodeSetup* n = new RobotRaconteurNodeSetup(node, s, node_name, tcp_port, flags);
				return n;
			}
SWIGINTERN RobotRaconteur::RobotRaconteurNodeSetup *new_RobotRaconteur_RobotRaconteurNodeSetup__SWIG_1(boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &node,boost::shared_ptr< RobotRaconteur::CommandLineConfigParser > const &config){
				std::vector<RR_SHARED_PTR<ServiceFactory> > s;
				RobotRaconteurNodeSetup* n = new RobotRaconteurNodeSetup(node, s, config);
				return n;
			}
SWIGINTERN RobotRaconteur::RobotRaconteurNodeSetup *new_RobotRaconteur_RobotRaconteurNodeSetup__SWIG_2(boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &node,std::string const &node_name,uint16_t tcp_port,uint32_t flags,uint32_t allowed_overrides,std::vector< std::string > const &args){
				std::vector<RR_SHARED_PTR<ServiceFactory> > s;
				RobotRaconteurNodeSetup* n = new RobotRaconteurNodeSetup(node, s, node_name, tcp_port, flags, allowed_overrides, args);
				return n;
			}


/* ---------------------------------------------------
 * C++ director class methods
 * --------------------------------------------------- */

#include "RobotRaconteurNETCSHARP_wrap.h"

SwigDirector_RobotRaconteurExceptionHelper::SwigDirector_RobotRaconteurExceptionHelper() : RobotRaconteurExceptionHelper(), Swig::Director() {
  swig_init_callbacks();
}

void SwigDirector_RobotRaconteurExceptionHelper::SetRobotRaconteurException(RobotRaconteur::HandlerErrorInfo const &error) {
  void * jerror = 0 ;
  
  if (!swig_callbackSetRobotRaconteurException) {
    RobotRaconteurExceptionHelper::SetRobotRaconteurException(error);
    return;
  } else {
    jerror = (RobotRaconteur::HandlerErrorInfo *) &error; 
    swig_callbackSetRobotRaconteurException(jerror);
  }
}

SwigDirector_RobotRaconteurExceptionHelper::~SwigDirector_RobotRaconteurExceptionHelper() {
  
}


void SwigDirector_RobotRaconteurExceptionHelper::swig_connect_director(SWIG_Callback0_t callbackSetRobotRaconteurException) {
  swig_callbackSetRobotRaconteurException = callbackSetRobotRaconteurException;
}

void SwigDirector_RobotRaconteurExceptionHelper::swig_init_callbacks() {
  swig_callbackSetRobotRaconteurException = 0;
}

SwigDirector_AsyncRequestDirector::SwigDirector_AsyncRequestDirector() : RobotRaconteur::AsyncRequestDirector(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_AsyncRequestDirector::~SwigDirector_AsyncRequestDirector() {
  
}


void SwigDirector_AsyncRequestDirector::handler(boost::intrusive_ptr< RobotRaconteur::MessageElement > ret, RobotRaconteur::HandlerErrorInfo &error) {
  void * jret  ;
  void * jerror = 0 ;
  
  if (!swig_callbackhandler) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::AsyncRequestDirector::handler");
    return;
  } else {
    //jret = ret ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< RobotRaconteur::MessageElement >(ret) : 0;
    if (ret) {
      intrusive_ptr_add_ref((&ret)->get());
      *(boost::shared_ptr< RobotRaconteur::MessageElement > **)&jret = new boost::shared_ptr< RobotRaconteur::MessageElement >((&ret)->get(), SWIG_intrusive_deleter< RobotRaconteur::MessageElement >());
    } else {
      *(boost::shared_ptr< RobotRaconteur::MessageElement > **)&jret = 0;
    }
    
    jerror = (RobotRaconteur::HandlerErrorInfo *) &error; 
    swig_callbackhandler(jret, jerror);
  }
}

void SwigDirector_AsyncRequestDirector::swig_connect_director(SWIG_Callback0_t callbackhandler) {
  swig_callbackhandler = callbackhandler;
}

void SwigDirector_AsyncRequestDirector::swig_init_callbacks() {
  swig_callbackhandler = 0;
}

SwigDirector_AsyncVoidReturnDirector::SwigDirector_AsyncVoidReturnDirector() : RobotRaconteur::AsyncVoidReturnDirector(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_AsyncVoidReturnDirector::~SwigDirector_AsyncVoidReturnDirector() {
  
}


void SwigDirector_AsyncVoidReturnDirector::handler(RobotRaconteur::HandlerErrorInfo &error) {
  void * jerror = 0 ;
  
  if (!swig_callbackhandler) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::AsyncVoidReturnDirector::handler");
    return;
  } else {
    jerror = (RobotRaconteur::HandlerErrorInfo *) &error; 
    swig_callbackhandler(jerror);
  }
}

void SwigDirector_AsyncVoidReturnDirector::swig_connect_director(SWIG_Callback0_t callbackhandler) {
  swig_callbackhandler = callbackhandler;
}

void SwigDirector_AsyncVoidReturnDirector::swig_init_callbacks() {
  swig_callbackhandler = 0;
}

SwigDirector_AsyncVoidNoErrReturnDirector::SwigDirector_AsyncVoidNoErrReturnDirector() : RobotRaconteur::AsyncVoidNoErrReturnDirector(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_AsyncVoidNoErrReturnDirector::~SwigDirector_AsyncVoidNoErrReturnDirector() {
  
}


void SwigDirector_AsyncVoidNoErrReturnDirector::handler() {
  if (!swig_callbackhandler) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::AsyncVoidNoErrReturnDirector::handler");
    return;
  } else {
    swig_callbackhandler();
  }
}

void SwigDirector_AsyncVoidNoErrReturnDirector::swig_connect_director(SWIG_Callback0_t callbackhandler) {
  swig_callbackhandler = callbackhandler;
}

void SwigDirector_AsyncVoidNoErrReturnDirector::swig_init_callbacks() {
  swig_callbackhandler = 0;
}

SwigDirector_AsyncStringReturnDirector::SwigDirector_AsyncStringReturnDirector() : RobotRaconteur::AsyncStringReturnDirector(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_AsyncStringReturnDirector::~SwigDirector_AsyncStringReturnDirector() {
  
}


void SwigDirector_AsyncStringReturnDirector::handler(std::string const &ret, RobotRaconteur::HandlerErrorInfo &error) {
  char * jret = 0 ;
  void * jerror = 0 ;
  
  if (!swig_callbackhandler) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::AsyncStringReturnDirector::handler");
    return;
  } else {
    jret = SWIG_csharp_string_callback((&ret)->c_str()); 
    jerror = (RobotRaconteur::HandlerErrorInfo *) &error; 
    swig_callbackhandler(jret, jerror);
  }
}

void SwigDirector_AsyncStringReturnDirector::swig_connect_director(SWIG_Callback0_t callbackhandler) {
  swig_callbackhandler = callbackhandler;
}

void SwigDirector_AsyncStringReturnDirector::swig_init_callbacks() {
  swig_callbackhandler = 0;
}

SwigDirector_AsyncUInt32ReturnDirector::SwigDirector_AsyncUInt32ReturnDirector() : RobotRaconteur::AsyncUInt32ReturnDirector(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_AsyncUInt32ReturnDirector::~SwigDirector_AsyncUInt32ReturnDirector() {
  
}


void SwigDirector_AsyncUInt32ReturnDirector::handler(uint32_t ret, RobotRaconteur::HandlerErrorInfo &error) {
  unsigned int jret  ;
  void * jerror = 0 ;
  
  if (!swig_callbackhandler) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::AsyncUInt32ReturnDirector::handler");
    return;
  } else {
    jret = ret;
    jerror = (RobotRaconteur::HandlerErrorInfo *) &error; 
    swig_callbackhandler(jret, jerror);
  }
}

void SwigDirector_AsyncUInt32ReturnDirector::swig_connect_director(SWIG_Callback0_t callbackhandler) {
  swig_callbackhandler = callbackhandler;
}

void SwigDirector_AsyncUInt32ReturnDirector::swig_init_callbacks() {
  swig_callbackhandler = 0;
}

SwigDirector_AsyncTimerEventReturnDirector::SwigDirector_AsyncTimerEventReturnDirector() : RobotRaconteur::AsyncTimerEventReturnDirector(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_AsyncTimerEventReturnDirector::~SwigDirector_AsyncTimerEventReturnDirector() {
  
}


void SwigDirector_AsyncTimerEventReturnDirector::handler(RobotRaconteur::TimerEvent const &ret, RobotRaconteur::HandlerErrorInfo &error) {
  void * jret = 0 ;
  void * jerror = 0 ;
  
  if (!swig_callbackhandler) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::AsyncTimerEventReturnDirector::handler");
    return;
  } else {
    jret = (RobotRaconteur::TimerEvent *) &ret; 
    jerror = (RobotRaconteur::HandlerErrorInfo *) &error; 
    swig_callbackhandler(jret, jerror);
  }
}

void SwigDirector_AsyncTimerEventReturnDirector::swig_connect_director(SWIG_Callback0_t callbackhandler) {
  swig_callbackhandler = callbackhandler;
}

void SwigDirector_AsyncTimerEventReturnDirector::swig_init_callbacks() {
  swig_callbackhandler = 0;
}

SwigDirector_WrappedPipeEndpointDirector::SwigDirector_WrappedPipeEndpointDirector() : RobotRaconteur::WrappedPipeEndpointDirector(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_WrappedPipeEndpointDirector::~SwigDirector_WrappedPipeEndpointDirector() {
  
}


void SwigDirector_WrappedPipeEndpointDirector::PipeEndpointClosedCallback() {
  if (!swig_callbackPipeEndpointClosedCallback) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedPipeEndpointDirector::PipeEndpointClosedCallback");
    return;
  } else {
    swig_callbackPipeEndpointClosedCallback();
  }
}

void SwigDirector_WrappedPipeEndpointDirector::PacketReceivedEvent() {
  if (!swig_callbackPacketReceivedEvent) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedPipeEndpointDirector::PacketReceivedEvent");
    return;
  } else {
    swig_callbackPacketReceivedEvent();
  }
}

void SwigDirector_WrappedPipeEndpointDirector::PacketAckReceivedEvent(uint32_t packetnum) {
  unsigned int jpacketnum  ;
  
  if (!swig_callbackPacketAckReceivedEvent) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedPipeEndpointDirector::PacketAckReceivedEvent");
    return;
  } else {
    jpacketnum = packetnum;
    swig_callbackPacketAckReceivedEvent(jpacketnum);
  }
}

void SwigDirector_WrappedPipeEndpointDirector::swig_connect_director(SWIG_Callback0_t callbackPipeEndpointClosedCallback, SWIG_Callback1_t callbackPacketReceivedEvent, SWIG_Callback2_t callbackPacketAckReceivedEvent) {
  swig_callbackPipeEndpointClosedCallback = callbackPipeEndpointClosedCallback;
  swig_callbackPacketReceivedEvent = callbackPacketReceivedEvent;
  swig_callbackPacketAckReceivedEvent = callbackPacketAckReceivedEvent;
}

void SwigDirector_WrappedPipeEndpointDirector::swig_init_callbacks() {
  swig_callbackPipeEndpointClosedCallback = 0;
  swig_callbackPacketReceivedEvent = 0;
  swig_callbackPacketAckReceivedEvent = 0;
}

SwigDirector_AsyncPipeEndpointReturnDirector::SwigDirector_AsyncPipeEndpointReturnDirector() : RobotRaconteur::AsyncPipeEndpointReturnDirector(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_AsyncPipeEndpointReturnDirector::~SwigDirector_AsyncPipeEndpointReturnDirector() {
  
}


void SwigDirector_AsyncPipeEndpointReturnDirector::handler(boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > const &ep, RobotRaconteur::HandlerErrorInfo &error) {
  void * jep = 0 ;
  void * jerror = 0 ;
  
  if (!swig_callbackhandler) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::AsyncPipeEndpointReturnDirector::handler");
    return;
  } else {
    jep = ep ? new boost::shared_ptr<  RobotRaconteur::WrappedPipeEndpoint >(ep) : 0; 
    jerror = (RobotRaconteur::HandlerErrorInfo *) &error; 
    swig_callbackhandler(jep, jerror);
  }
}

void SwigDirector_AsyncPipeEndpointReturnDirector::swig_connect_director(SWIG_Callback0_t callbackhandler) {
  swig_callbackhandler = callbackhandler;
}

void SwigDirector_AsyncPipeEndpointReturnDirector::swig_init_callbacks() {
  swig_callbackhandler = 0;
}

SwigDirector_WrappedPipeServerConnectDirector::SwigDirector_WrappedPipeServerConnectDirector() : RobotRaconteur::WrappedPipeServerConnectDirector(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_WrappedPipeServerConnectDirector::~SwigDirector_WrappedPipeServerConnectDirector() {
  
}


void SwigDirector_WrappedPipeServerConnectDirector::PipeConnectCallback(boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > const &pipeendpoint) {
  void * jpipeendpoint = 0 ;
  
  if (!swig_callbackPipeConnectCallback) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedPipeServerConnectDirector::PipeConnectCallback");
    return;
  } else {
    jpipeendpoint = pipeendpoint ? new boost::shared_ptr<  RobotRaconteur::WrappedPipeEndpoint >(pipeendpoint) : 0; 
    swig_callbackPipeConnectCallback(jpipeendpoint);
  }
}

void SwigDirector_WrappedPipeServerConnectDirector::swig_connect_director(SWIG_Callback0_t callbackPipeConnectCallback) {
  swig_callbackPipeConnectCallback = callbackPipeConnectCallback;
}

void SwigDirector_WrappedPipeServerConnectDirector::swig_init_callbacks() {
  swig_callbackPipeConnectCallback = 0;
}

SwigDirector_WrappedPipeBroadcasterPredicateDirector::SwigDirector_WrappedPipeBroadcasterPredicateDirector() : RobotRaconteur::WrappedPipeBroadcasterPredicateDirector(), Swig::Director() {
  swig_init_callbacks();
}

bool SwigDirector_WrappedPipeBroadcasterPredicateDirector::Predicate(uint32_t client_endpoint, int32_t index) {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  unsigned int jclient_endpoint  ;
  int jindex  ;
  
  if (!swig_callbackPredicate) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedPipeBroadcasterPredicateDirector::Predicate");
    return c_result;
  } else {
    jclient_endpoint = client_endpoint;
    jindex = index;
    jresult = (unsigned int) swig_callbackPredicate(jclient_endpoint, jindex);
    c_result = jresult ? true : false; 
  }
  return c_result;
}

SwigDirector_WrappedPipeBroadcasterPredicateDirector::~SwigDirector_WrappedPipeBroadcasterPredicateDirector() {
  
}


void SwigDirector_WrappedPipeBroadcasterPredicateDirector::swig_connect_director(SWIG_Callback0_t callbackPredicate) {
  swig_callbackPredicate = callbackPredicate;
}

void SwigDirector_WrappedPipeBroadcasterPredicateDirector::swig_init_callbacks() {
  swig_callbackPredicate = 0;
}

SwigDirector_WrappedWireConnectionDirector::SwigDirector_WrappedWireConnectionDirector() : RobotRaconteur::WrappedWireConnectionDirector(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_WrappedWireConnectionDirector::~SwigDirector_WrappedWireConnectionDirector() {
  
}


void SwigDirector_WrappedWireConnectionDirector::WireValueChanged(boost::intrusive_ptr< RobotRaconteur::MessageElement > value, RobotRaconteur::TimeSpec const &time) {
  void * jvalue  ;
  void * jtime = 0 ;
  
  if (!swig_callbackWireValueChanged) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedWireConnectionDirector::WireValueChanged");
    return;
  } else {
    //jvalue = value ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< RobotRaconteur::MessageElement >(value) : 0;
    if (value) {
      intrusive_ptr_add_ref((&value)->get());
      *(boost::shared_ptr< RobotRaconteur::MessageElement > **)&jvalue = new boost::shared_ptr< RobotRaconteur::MessageElement >((&value)->get(), SWIG_intrusive_deleter< RobotRaconteur::MessageElement >());
    } else {
      *(boost::shared_ptr< RobotRaconteur::MessageElement > **)&jvalue = 0;
    }
    
    jtime = (RobotRaconteur::TimeSpec *) &time; 
    swig_callbackWireValueChanged(jvalue, jtime);
  }
}

void SwigDirector_WrappedWireConnectionDirector::WireConnectionClosedCallback() {
  if (!swig_callbackWireConnectionClosedCallback) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedWireConnectionDirector::WireConnectionClosedCallback");
    return;
  } else {
    swig_callbackWireConnectionClosedCallback();
  }
}

void SwigDirector_WrappedWireConnectionDirector::swig_connect_director(SWIG_Callback0_t callbackWireValueChanged, SWIG_Callback1_t callbackWireConnectionClosedCallback) {
  swig_callbackWireValueChanged = callbackWireValueChanged;
  swig_callbackWireConnectionClosedCallback = callbackWireConnectionClosedCallback;
}

void SwigDirector_WrappedWireConnectionDirector::swig_init_callbacks() {
  swig_callbackWireValueChanged = 0;
  swig_callbackWireConnectionClosedCallback = 0;
}

SwigDirector_AsyncWireConnectionReturnDirector::SwigDirector_AsyncWireConnectionReturnDirector() : RobotRaconteur::AsyncWireConnectionReturnDirector(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_AsyncWireConnectionReturnDirector::~SwigDirector_AsyncWireConnectionReturnDirector() {
  
}


void SwigDirector_AsyncWireConnectionReturnDirector::handler(boost::shared_ptr< RobotRaconteur::WrappedWireConnection > const &ep, RobotRaconteur::HandlerErrorInfo &error) {
  void * jep = 0 ;
  void * jerror = 0 ;
  
  if (!swig_callbackhandler) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::AsyncWireConnectionReturnDirector::handler");
    return;
  } else {
    jep = ep ? new boost::shared_ptr<  RobotRaconteur::WrappedWireConnection >(ep) : 0; 
    jerror = (RobotRaconteur::HandlerErrorInfo *) &error; 
    swig_callbackhandler(jep, jerror);
  }
}

void SwigDirector_AsyncWireConnectionReturnDirector::swig_connect_director(SWIG_Callback0_t callbackhandler) {
  swig_callbackhandler = callbackhandler;
}

void SwigDirector_AsyncWireConnectionReturnDirector::swig_init_callbacks() {
  swig_callbackhandler = 0;
}

SwigDirector_AsyncWirePeekReturnDirector::SwigDirector_AsyncWirePeekReturnDirector() : RobotRaconteur::AsyncWirePeekReturnDirector(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_AsyncWirePeekReturnDirector::~SwigDirector_AsyncWirePeekReturnDirector() {
  
}


void SwigDirector_AsyncWirePeekReturnDirector::handler(boost::intrusive_ptr< RobotRaconteur::MessageElement > value, RobotRaconteur::TimeSpec const &ts, RobotRaconteur::HandlerErrorInfo &error) {
  void * jvalue  ;
  void * jts = 0 ;
  void * jerror = 0 ;
  
  if (!swig_callbackhandler) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::AsyncWirePeekReturnDirector::handler");
    return;
  } else {
    //jvalue = value ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< RobotRaconteur::MessageElement >(value) : 0;
    if (value) {
      intrusive_ptr_add_ref((&value)->get());
      *(boost::shared_ptr< RobotRaconteur::MessageElement > **)&jvalue = new boost::shared_ptr< RobotRaconteur::MessageElement >((&value)->get(), SWIG_intrusive_deleter< RobotRaconteur::MessageElement >());
    } else {
      *(boost::shared_ptr< RobotRaconteur::MessageElement > **)&jvalue = 0;
    }
    
    jts = (RobotRaconteur::TimeSpec *) &ts; 
    jerror = (RobotRaconteur::HandlerErrorInfo *) &error; 
    swig_callbackhandler(jvalue, jts, jerror);
  }
}

void SwigDirector_AsyncWirePeekReturnDirector::swig_connect_director(SWIG_Callback0_t callbackhandler) {
  swig_callbackhandler = callbackhandler;
}

void SwigDirector_AsyncWirePeekReturnDirector::swig_init_callbacks() {
  swig_callbackhandler = 0;
}

SwigDirector_WrappedWireServerConnectDirector::SwigDirector_WrappedWireServerConnectDirector() : RobotRaconteur::WrappedWireServerConnectDirector(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_WrappedWireServerConnectDirector::~SwigDirector_WrappedWireServerConnectDirector() {
  
}


void SwigDirector_WrappedWireServerConnectDirector::WireConnectCallback(boost::shared_ptr< RobotRaconteur::WrappedWireConnection > const &c) {
  void * jc = 0 ;
  
  if (!swig_callbackWireConnectCallback) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedWireServerConnectDirector::WireConnectCallback");
    return;
  } else {
    jc = c ? new boost::shared_ptr<  RobotRaconteur::WrappedWireConnection >(c) : 0; 
    swig_callbackWireConnectCallback(jc);
  }
}

void SwigDirector_WrappedWireServerConnectDirector::swig_connect_director(SWIG_Callback0_t callbackWireConnectCallback) {
  swig_callbackWireConnectCallback = callbackWireConnectCallback;
}

void SwigDirector_WrappedWireServerConnectDirector::swig_init_callbacks() {
  swig_callbackWireConnectCallback = 0;
}

SwigDirector_WrappedWireServerPeekValueDirector::SwigDirector_WrappedWireServerPeekValueDirector() : RobotRaconteur::WrappedWireServerPeekValueDirector(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_WrappedWireServerPeekValueDirector::~SwigDirector_WrappedWireServerPeekValueDirector() {
  
}


boost::intrusive_ptr< RobotRaconteur::MessageElement > SwigDirector_WrappedWireServerPeekValueDirector::PeekValue(uint32_t const &ep) {
  boost::intrusive_ptr< RobotRaconteur::MessageElement > c_result ;
  void * jresult = 0 ;
  unsigned int jep = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg ;
  
  if (!swig_callbackPeekValue) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedWireServerPeekValueDirector::PeekValue");
    return c_result;
  } else {
    jep = ep;
    jresult = (void *) swig_callbackPeekValue(jep);
    
    //if (jresult) {
    //    SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST RobotRaconteur::MessageElement > *smartarg = (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST RobotRaconteur::MessageElement > *)jresult;
    //    c_result = *smartarg;
    //  }
    smartarg = *(boost::shared_ptr< RobotRaconteur::MessageElement >**)&jresult;
    if (smartarg) {
      c_result = boost::intrusive_ptr< RobotRaconteur::MessageElement >(smartarg->get(), true);
    }
    
    
  }
  return c_result;
}

void SwigDirector_WrappedWireServerPeekValueDirector::swig_connect_director(SWIG_Callback0_t callbackPeekValue) {
  swig_callbackPeekValue = callbackPeekValue;
}

void SwigDirector_WrappedWireServerPeekValueDirector::swig_init_callbacks() {
  swig_callbackPeekValue = 0;
}

SwigDirector_WrappedWireServerPokeValueDirector::SwigDirector_WrappedWireServerPokeValueDirector() : RobotRaconteur::WrappedWireServerPokeValueDirector(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_WrappedWireServerPokeValueDirector::~SwigDirector_WrappedWireServerPokeValueDirector() {
  
}


void SwigDirector_WrappedWireServerPokeValueDirector::PokeValue(boost::intrusive_ptr< RobotRaconteur::MessageElement > value, RobotRaconteur::TimeSpec const &ts, uint32_t const &ep) {
  void * jvalue  ;
  void * jts = 0 ;
  unsigned int jep = 0 ;
  
  if (!swig_callbackPokeValue) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedWireServerPokeValueDirector::PokeValue");
    return;
  } else {
    //jvalue = value ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< RobotRaconteur::MessageElement >(value) : 0;
    if (value) {
      intrusive_ptr_add_ref((&value)->get());
      *(boost::shared_ptr< RobotRaconteur::MessageElement > **)&jvalue = new boost::shared_ptr< RobotRaconteur::MessageElement >((&value)->get(), SWIG_intrusive_deleter< RobotRaconteur::MessageElement >());
    } else {
      *(boost::shared_ptr< RobotRaconteur::MessageElement > **)&jvalue = 0;
    }
    
    jts = (RobotRaconteur::TimeSpec *) &ts; 
    jep = ep;
    swig_callbackPokeValue(jvalue, jts, jep);
  }
}

void SwigDirector_WrappedWireServerPokeValueDirector::swig_connect_director(SWIG_Callback0_t callbackPokeValue) {
  swig_callbackPokeValue = callbackPokeValue;
}

void SwigDirector_WrappedWireServerPokeValueDirector::swig_init_callbacks() {
  swig_callbackPokeValue = 0;
}

SwigDirector_WrappedWireBroadcasterPredicateDirector::SwigDirector_WrappedWireBroadcasterPredicateDirector() : RobotRaconteur::WrappedWireBroadcasterPredicateDirector(), Swig::Director() {
  swig_init_callbacks();
}

bool SwigDirector_WrappedWireBroadcasterPredicateDirector::Predicate(uint32_t client_endpoint) {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  unsigned int jclient_endpoint  ;
  
  if (!swig_callbackPredicate) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedWireBroadcasterPredicateDirector::Predicate");
    return c_result;
  } else {
    jclient_endpoint = client_endpoint;
    jresult = (unsigned int) swig_callbackPredicate(jclient_endpoint);
    c_result = jresult ? true : false; 
  }
  return c_result;
}

SwigDirector_WrappedWireBroadcasterPredicateDirector::~SwigDirector_WrappedWireBroadcasterPredicateDirector() {
  
}


void SwigDirector_WrappedWireBroadcasterPredicateDirector::swig_connect_director(SWIG_Callback0_t callbackPredicate) {
  swig_callbackPredicate = callbackPredicate;
}

void SwigDirector_WrappedWireBroadcasterPredicateDirector::swig_init_callbacks() {
  swig_callbackPredicate = 0;
}

SwigDirector_WrappedPodArrayMemoryClientBuffer::SwigDirector_WrappedPodArrayMemoryClientBuffer() : RobotRaconteur::WrappedPodArrayMemoryClientBuffer(), Swig::Director() {
  swig_init_callbacks();
}

void SwigDirector_WrappedPodArrayMemoryClientBuffer::UnpackReadResult(boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > res, uint64_t bufferpos, uint64_t count) {
  void * jres  ;
  unsigned long long jbufferpos  ;
  unsigned long long jcount  ;
  
  if (!swig_callbackUnpackReadResult) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedPodArrayMemoryClientBuffer::UnpackReadResult");
    return;
  } else {
    //jres = res ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< RobotRaconteur::MessageElementNestedElementList >(res) : 0;
    if (res) {
      intrusive_ptr_add_ref((&res)->get());
      *(boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > **)&jres = new boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList >((&res)->get(), SWIG_intrusive_deleter< RobotRaconteur::MessageElementNestedElementList >());
    } else {
      *(boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > **)&jres = 0;
    }
    
    jbufferpos = bufferpos;
    jcount = count;
    swig_callbackUnpackReadResult(jres, jbufferpos, jcount);
  }
}

boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > SwigDirector_WrappedPodArrayMemoryClientBuffer::PackWriteRequest(uint64_t bufferpos, uint64_t count) {
  boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > c_result ;
  void * jresult = 0 ;
  unsigned long long jbufferpos  ;
  unsigned long long jcount  ;
  boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > *smartarg ;
  
  if (!swig_callbackPackWriteRequest) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedPodArrayMemoryClientBuffer::PackWriteRequest");
    return c_result;
  } else {
    jbufferpos = bufferpos;
    jcount = count;
    jresult = (void *) swig_callbackPackWriteRequest(jbufferpos, jcount);
    
    //if (jresult) {
    //    SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST RobotRaconteur::MessageElementNestedElementList > *smartarg = (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST RobotRaconteur::MessageElementNestedElementList > *)jresult;
    //    c_result = *smartarg;
    //  }
    smartarg = *(boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList >**)&jresult;
    if (smartarg) {
      c_result = boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList >(smartarg->get(), true);
    }
    
    
  }
  return c_result;
}

uint64_t SwigDirector_WrappedPodArrayMemoryClientBuffer::GetBufferLength() {
  uint64_t c_result = SwigValueInit< uint64_t >() ;
  unsigned long long jresult = 0 ;
  
  if (!swig_callbackGetBufferLength) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedPodArrayMemoryClientBuffer::GetBufferLength");
    return c_result;
  } else {
    jresult = (unsigned long long) swig_callbackGetBufferLength();
    c_result = (uint64_t)jresult; 
  }
  return c_result;
}

SwigDirector_WrappedPodArrayMemoryClientBuffer::~SwigDirector_WrappedPodArrayMemoryClientBuffer() {
  
}


void SwigDirector_WrappedPodArrayMemoryClientBuffer::swig_connect_director(SWIG_Callback0_t callbackUnpackReadResult, SWIG_Callback1_t callbackPackWriteRequest, SWIG_Callback2_t callbackGetBufferLength) {
  swig_callbackUnpackReadResult = callbackUnpackReadResult;
  swig_callbackPackWriteRequest = callbackPackWriteRequest;
  swig_callbackGetBufferLength = callbackGetBufferLength;
}

void SwigDirector_WrappedPodArrayMemoryClientBuffer::swig_init_callbacks() {
  swig_callbackUnpackReadResult = 0;
  swig_callbackPackWriteRequest = 0;
  swig_callbackGetBufferLength = 0;
}

SwigDirector_WrappedPodMultiDimArrayMemoryClientBuffer::SwigDirector_WrappedPodMultiDimArrayMemoryClientBuffer() : RobotRaconteur::WrappedPodMultiDimArrayMemoryClientBuffer(), Swig::Director() {
  swig_init_callbacks();
}

void SwigDirector_WrappedPodMultiDimArrayMemoryClientBuffer::UnpackReadResult(boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > res, std::vector< uint64_t > const &bufferpos, std::vector< uint64_t > const &count) {
  void * jres  ;
  void * jbufferpos = 0 ;
  void * jcount = 0 ;
  
  if (!swig_callbackUnpackReadResult) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedPodMultiDimArrayMemoryClientBuffer::UnpackReadResult");
    return;
  } else {
    //jres = res ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< RobotRaconteur::MessageElementNestedElementList >(res) : 0;
    if (res) {
      intrusive_ptr_add_ref((&res)->get());
      *(boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > **)&jres = new boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList >((&res)->get(), SWIG_intrusive_deleter< RobotRaconteur::MessageElementNestedElementList >());
    } else {
      *(boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > **)&jres = 0;
    }
    
    jbufferpos = (std::vector< uint64_t > *) &bufferpos; 
    jcount = (std::vector< uint64_t > *) &count; 
    swig_callbackUnpackReadResult(jres, jbufferpos, jcount);
  }
}

boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > SwigDirector_WrappedPodMultiDimArrayMemoryClientBuffer::PackWriteRequest(std::vector< uint64_t > const &bufferpos, std::vector< uint64_t > const &count) {
  boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > c_result ;
  void * jresult = 0 ;
  void * jbufferpos = 0 ;
  void * jcount = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > *smartarg ;
  
  if (!swig_callbackPackWriteRequest) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedPodMultiDimArrayMemoryClientBuffer::PackWriteRequest");
    return c_result;
  } else {
    jbufferpos = (std::vector< uint64_t > *) &bufferpos; 
    jcount = (std::vector< uint64_t > *) &count; 
    jresult = (void *) swig_callbackPackWriteRequest(jbufferpos, jcount);
    
    //if (jresult) {
    //    SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST RobotRaconteur::MessageElementNestedElementList > *smartarg = (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST RobotRaconteur::MessageElementNestedElementList > *)jresult;
    //    c_result = *smartarg;
    //  }
    smartarg = *(boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList >**)&jresult;
    if (smartarg) {
      c_result = boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList >(smartarg->get(), true);
    }
    
    
  }
  return c_result;
}

SwigDirector_WrappedPodMultiDimArrayMemoryClientBuffer::~SwigDirector_WrappedPodMultiDimArrayMemoryClientBuffer() {
  
}


void SwigDirector_WrappedPodMultiDimArrayMemoryClientBuffer::swig_connect_director(SWIG_Callback0_t callbackUnpackReadResult, SWIG_Callback1_t callbackPackWriteRequest) {
  swig_callbackUnpackReadResult = callbackUnpackReadResult;
  swig_callbackPackWriteRequest = callbackPackWriteRequest;
}

void SwigDirector_WrappedPodMultiDimArrayMemoryClientBuffer::swig_init_callbacks() {
  swig_callbackUnpackReadResult = 0;
  swig_callbackPackWriteRequest = 0;
}

SwigDirector_WrappedArrayMemoryDirector::SwigDirector_WrappedArrayMemoryDirector() : RobotRaconteur::WrappedArrayMemoryDirector(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_WrappedArrayMemoryDirector::~SwigDirector_WrappedArrayMemoryDirector() {
  
}


uint64_t SwigDirector_WrappedArrayMemoryDirector::Length() {
  uint64_t c_result = SwigValueInit< uint64_t >() ;
  unsigned long long jresult = 0 ;
  
  if (!swig_callbackLength) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedArrayMemoryDirector::Length");
    return c_result;
  } else {
    jresult = (unsigned long long) swig_callbackLength();
    c_result = (uint64_t)jresult; 
  }
  return c_result;
}

void SwigDirector_WrappedArrayMemoryDirector::Read(uint64_t memorypos, boost::intrusive_ptr< RobotRaconteur::RRBaseArray > buffer, uint64_t bufferpos, uint64_t count) {
  unsigned long long jmemorypos  ;
  void * jbuffer  ;
  unsigned long long jbufferpos  ;
  unsigned long long jcount  ;
  
  if (!swig_callbackRead) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedArrayMemoryDirector::Read");
    return;
  } else {
    jmemorypos = memorypos;
    
    //jbuffer = buffer ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< RobotRaconteur::RRBaseArray >(buffer) : 0;
    if (buffer) {
      intrusive_ptr_add_ref((&buffer)->get());
      *(boost::shared_ptr< RobotRaconteur::RRBaseArray > **)&jbuffer = new boost::shared_ptr< RobotRaconteur::RRBaseArray >((&buffer)->get(), SWIG_intrusive_deleter< RobotRaconteur::RRBaseArray >());
    } else {
      *(boost::shared_ptr< RobotRaconteur::RRBaseArray > **)&jbuffer = 0;
    }
    
    jbufferpos = bufferpos;
    jcount = count;
    swig_callbackRead(jmemorypos, jbuffer, jbufferpos, jcount);
  }
}

void SwigDirector_WrappedArrayMemoryDirector::Write(uint64_t memorypos, boost::intrusive_ptr< RobotRaconteur::RRBaseArray > buffer, uint64_t bufferpos, uint64_t count) {
  unsigned long long jmemorypos  ;
  void * jbuffer  ;
  unsigned long long jbufferpos  ;
  unsigned long long jcount  ;
  
  if (!swig_callbackWrite) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedArrayMemoryDirector::Write");
    return;
  } else {
    jmemorypos = memorypos;
    
    //jbuffer = buffer ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< RobotRaconteur::RRBaseArray >(buffer) : 0;
    if (buffer) {
      intrusive_ptr_add_ref((&buffer)->get());
      *(boost::shared_ptr< RobotRaconteur::RRBaseArray > **)&jbuffer = new boost::shared_ptr< RobotRaconteur::RRBaseArray >((&buffer)->get(), SWIG_intrusive_deleter< RobotRaconteur::RRBaseArray >());
    } else {
      *(boost::shared_ptr< RobotRaconteur::RRBaseArray > **)&jbuffer = 0;
    }
    
    jbufferpos = bufferpos;
    jcount = count;
    swig_callbackWrite(jmemorypos, jbuffer, jbufferpos, jcount);
  }
}

void SwigDirector_WrappedArrayMemoryDirector::swig_connect_director(SWIG_Callback0_t callbackLength, SWIG_Callback1_t callbackRead, SWIG_Callback2_t callbackWrite) {
  swig_callbackLength = callbackLength;
  swig_callbackRead = callbackRead;
  swig_callbackWrite = callbackWrite;
}

void SwigDirector_WrappedArrayMemoryDirector::swig_init_callbacks() {
  swig_callbackLength = 0;
  swig_callbackRead = 0;
  swig_callbackWrite = 0;
}

SwigDirector_WrappedMultiDimArrayMemoryDirector::SwigDirector_WrappedMultiDimArrayMemoryDirector() : RobotRaconteur::WrappedMultiDimArrayMemoryDirector(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_WrappedMultiDimArrayMemoryDirector::~SwigDirector_WrappedMultiDimArrayMemoryDirector() {
  
}


std::vector< uint64_t > SwigDirector_WrappedMultiDimArrayMemoryDirector::Dimensions() {
  std::vector< uint64_t > c_result ;
  void * jresult = 0 ;
  
  if (!swig_callbackDimensions) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedMultiDimArrayMemoryDirector::Dimensions");
    return c_result;
  } else {
    jresult = (void *) swig_callbackDimensions();
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type std::vector< uint64_t >", 0);
      return c_result;
    }
    c_result = *(std::vector< uint64_t > *)jresult; 
  }
  return c_result;
}

uint64_t SwigDirector_WrappedMultiDimArrayMemoryDirector::DimCount() {
  uint64_t c_result = SwigValueInit< uint64_t >() ;
  unsigned long long jresult = 0 ;
  
  if (!swig_callbackDimCount) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedMultiDimArrayMemoryDirector::DimCount");
    return c_result;
  } else {
    jresult = (unsigned long long) swig_callbackDimCount();
    c_result = (uint64_t)jresult; 
  }
  return c_result;
}

void SwigDirector_WrappedMultiDimArrayMemoryDirector::Read(RobotRaconteur::WrappedMultiDimArrayMemoryParams *p) {
  void * jp = 0 ;
  
  if (!swig_callbackRead) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedMultiDimArrayMemoryDirector::Read");
    return;
  } else {
    jp = (void *) p; 
    swig_callbackRead(jp);
  }
}

void SwigDirector_WrappedMultiDimArrayMemoryDirector::Write(RobotRaconteur::WrappedMultiDimArrayMemoryParams *p) {
  void * jp = 0 ;
  
  if (!swig_callbackWrite) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedMultiDimArrayMemoryDirector::Write");
    return;
  } else {
    jp = (void *) p; 
    swig_callbackWrite(jp);
  }
}

void SwigDirector_WrappedMultiDimArrayMemoryDirector::swig_connect_director(SWIG_Callback0_t callbackDimensions, SWIG_Callback1_t callbackDimCount, SWIG_Callback2_t callbackRead, SWIG_Callback3_t callbackWrite) {
  swig_callbackDimensions = callbackDimensions;
  swig_callbackDimCount = callbackDimCount;
  swig_callbackRead = callbackRead;
  swig_callbackWrite = callbackWrite;
}

void SwigDirector_WrappedMultiDimArrayMemoryDirector::swig_init_callbacks() {
  swig_callbackDimensions = 0;
  swig_callbackDimCount = 0;
  swig_callbackRead = 0;
  swig_callbackWrite = 0;
}

SwigDirector_WrappedPodArrayMemoryDirector::SwigDirector_WrappedPodArrayMemoryDirector() : RobotRaconteur::WrappedPodArrayMemoryDirector(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_WrappedPodArrayMemoryDirector::~SwigDirector_WrappedPodArrayMemoryDirector() {
  
}


uint64_t SwigDirector_WrappedPodArrayMemoryDirector::Length() {
  uint64_t c_result = SwigValueInit< uint64_t >() ;
  unsigned long long jresult = 0 ;
  
  if (!swig_callbackLength) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedPodArrayMemoryDirector::Length");
    return c_result;
  } else {
    jresult = (unsigned long long) swig_callbackLength();
    c_result = (uint64_t)jresult; 
  }
  return c_result;
}

boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > SwigDirector_WrappedPodArrayMemoryDirector::Read(uint64_t memorypos, uint64_t bufferpos, uint64_t count) {
  boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > c_result ;
  void * jresult = 0 ;
  unsigned long long jmemorypos  ;
  unsigned long long jbufferpos  ;
  unsigned long long jcount  ;
  boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > *smartarg ;
  
  if (!swig_callbackRead) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedPodArrayMemoryDirector::Read");
    return c_result;
  } else {
    jmemorypos = memorypos;
    jbufferpos = bufferpos;
    jcount = count;
    jresult = (void *) swig_callbackRead(jmemorypos, jbufferpos, jcount);
    
    //if (jresult) {
    //    SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST RobotRaconteur::MessageElementNestedElementList > *smartarg = (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST RobotRaconteur::MessageElementNestedElementList > *)jresult;
    //    c_result = *smartarg;
    //  }
    smartarg = *(boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList >**)&jresult;
    if (smartarg) {
      c_result = boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList >(smartarg->get(), true);
    }
    
    
  }
  return c_result;
}

void SwigDirector_WrappedPodArrayMemoryDirector::Write(uint64_t memorypos, boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > buffer, uint64_t bufferpos, uint64_t count) {
  unsigned long long jmemorypos  ;
  void * jbuffer  ;
  unsigned long long jbufferpos  ;
  unsigned long long jcount  ;
  
  if (!swig_callbackWrite) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedPodArrayMemoryDirector::Write");
    return;
  } else {
    jmemorypos = memorypos;
    
    //jbuffer = buffer ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< RobotRaconteur::MessageElementNestedElementList >(buffer) : 0;
    if (buffer) {
      intrusive_ptr_add_ref((&buffer)->get());
      *(boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > **)&jbuffer = new boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList >((&buffer)->get(), SWIG_intrusive_deleter< RobotRaconteur::MessageElementNestedElementList >());
    } else {
      *(boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > **)&jbuffer = 0;
    }
    
    jbufferpos = bufferpos;
    jcount = count;
    swig_callbackWrite(jmemorypos, jbuffer, jbufferpos, jcount);
  }
}

void SwigDirector_WrappedPodArrayMemoryDirector::swig_connect_director(SWIG_Callback0_t callbackLength, SWIG_Callback1_t callbackRead, SWIG_Callback2_t callbackWrite) {
  swig_callbackLength = callbackLength;
  swig_callbackRead = callbackRead;
  swig_callbackWrite = callbackWrite;
}

void SwigDirector_WrappedPodArrayMemoryDirector::swig_init_callbacks() {
  swig_callbackLength = 0;
  swig_callbackRead = 0;
  swig_callbackWrite = 0;
}

SwigDirector_WrappedPodMultiDimArrayMemoryDirector::SwigDirector_WrappedPodMultiDimArrayMemoryDirector() : RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_WrappedPodMultiDimArrayMemoryDirector::~SwigDirector_WrappedPodMultiDimArrayMemoryDirector() {
  
}


std::vector< uint64_t > SwigDirector_WrappedPodMultiDimArrayMemoryDirector::Dimensions() {
  std::vector< uint64_t > c_result ;
  void * jresult = 0 ;
  
  if (!swig_callbackDimensions) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector::Dimensions");
    return c_result;
  } else {
    jresult = (void *) swig_callbackDimensions();
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type std::vector< uint64_t >", 0);
      return c_result;
    }
    c_result = *(std::vector< uint64_t > *)jresult; 
  }
  return c_result;
}

uint64_t SwigDirector_WrappedPodMultiDimArrayMemoryDirector::DimCount() {
  uint64_t c_result = SwigValueInit< uint64_t >() ;
  unsigned long long jresult = 0 ;
  
  if (!swig_callbackDimCount) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector::DimCount");
    return c_result;
  } else {
    jresult = (unsigned long long) swig_callbackDimCount();
    c_result = (uint64_t)jresult; 
  }
  return c_result;
}

boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > SwigDirector_WrappedPodMultiDimArrayMemoryDirector::Read(std::vector< uint64_t > const &memorypos, std::vector< uint64_t > const &bufferpos, std::vector< uint64_t > const &count) {
  boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > c_result ;
  void * jresult = 0 ;
  void * jmemorypos = 0 ;
  void * jbufferpos = 0 ;
  void * jcount = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > *smartarg ;
  
  if (!swig_callbackRead) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector::Read");
    return c_result;
  } else {
    jmemorypos = (std::vector< uint64_t > *) &memorypos; 
    jbufferpos = (std::vector< uint64_t > *) &bufferpos; 
    jcount = (std::vector< uint64_t > *) &count; 
    jresult = (void *) swig_callbackRead(jmemorypos, jbufferpos, jcount);
    
    //if (jresult) {
    //    SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST RobotRaconteur::MessageElementNestedElementList > *smartarg = (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST RobotRaconteur::MessageElementNestedElementList > *)jresult;
    //    c_result = *smartarg;
    //  }
    smartarg = *(boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList >**)&jresult;
    if (smartarg) {
      c_result = boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList >(smartarg->get(), true);
    }
    
    
  }
  return c_result;
}

void SwigDirector_WrappedPodMultiDimArrayMemoryDirector::Write(std::vector< uint64_t > const &memorypos, boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > buffer, std::vector< uint64_t > const &bufferpos, std::vector< uint64_t > const &count) {
  void * jmemorypos = 0 ;
  void * jbuffer  ;
  void * jbufferpos = 0 ;
  void * jcount = 0 ;
  
  if (!swig_callbackWrite) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector::Write");
    return;
  } else {
    jmemorypos = (std::vector< uint64_t > *) &memorypos; 
    
    //jbuffer = buffer ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< RobotRaconteur::MessageElementNestedElementList >(buffer) : 0;
    if (buffer) {
      intrusive_ptr_add_ref((&buffer)->get());
      *(boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > **)&jbuffer = new boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList >((&buffer)->get(), SWIG_intrusive_deleter< RobotRaconteur::MessageElementNestedElementList >());
    } else {
      *(boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > **)&jbuffer = 0;
    }
    
    jbufferpos = (std::vector< uint64_t > *) &bufferpos; 
    jcount = (std::vector< uint64_t > *) &count; 
    swig_callbackWrite(jmemorypos, jbuffer, jbufferpos, jcount);
  }
}

void SwigDirector_WrappedPodMultiDimArrayMemoryDirector::swig_connect_director(SWIG_Callback0_t callbackDimensions, SWIG_Callback1_t callbackDimCount, SWIG_Callback2_t callbackRead, SWIG_Callback3_t callbackWrite) {
  swig_callbackDimensions = callbackDimensions;
  swig_callbackDimCount = callbackDimCount;
  swig_callbackRead = callbackRead;
  swig_callbackWrite = callbackWrite;
}

void SwigDirector_WrappedPodMultiDimArrayMemoryDirector::swig_init_callbacks() {
  swig_callbackDimensions = 0;
  swig_callbackDimCount = 0;
  swig_callbackRead = 0;
  swig_callbackWrite = 0;
}

SwigDirector_WrappedNamedArrayMemoryClientBuffer::SwigDirector_WrappedNamedArrayMemoryClientBuffer() : RobotRaconteur::WrappedNamedArrayMemoryClientBuffer(), Swig::Director() {
  swig_init_callbacks();
}

void SwigDirector_WrappedNamedArrayMemoryClientBuffer::UnpackReadResult(boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > res, uint64_t bufferpos, uint64_t count) {
  void * jres  ;
  unsigned long long jbufferpos  ;
  unsigned long long jcount  ;
  
  if (!swig_callbackUnpackReadResult) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedNamedArrayMemoryClientBuffer::UnpackReadResult");
    return;
  } else {
    //jres = res ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< RobotRaconteur::MessageElementNestedElementList >(res) : 0;
    if (res) {
      intrusive_ptr_add_ref((&res)->get());
      *(boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > **)&jres = new boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList >((&res)->get(), SWIG_intrusive_deleter< RobotRaconteur::MessageElementNestedElementList >());
    } else {
      *(boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > **)&jres = 0;
    }
    
    jbufferpos = bufferpos;
    jcount = count;
    swig_callbackUnpackReadResult(jres, jbufferpos, jcount);
  }
}

boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > SwigDirector_WrappedNamedArrayMemoryClientBuffer::PackWriteRequest(uint64_t bufferpos, uint64_t count) {
  boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > c_result ;
  void * jresult = 0 ;
  unsigned long long jbufferpos  ;
  unsigned long long jcount  ;
  boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > *smartarg ;
  
  if (!swig_callbackPackWriteRequest) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedNamedArrayMemoryClientBuffer::PackWriteRequest");
    return c_result;
  } else {
    jbufferpos = bufferpos;
    jcount = count;
    jresult = (void *) swig_callbackPackWriteRequest(jbufferpos, jcount);
    
    //if (jresult) {
    //    SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST RobotRaconteur::MessageElementNestedElementList > *smartarg = (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST RobotRaconteur::MessageElementNestedElementList > *)jresult;
    //    c_result = *smartarg;
    //  }
    smartarg = *(boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList >**)&jresult;
    if (smartarg) {
      c_result = boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList >(smartarg->get(), true);
    }
    
    
  }
  return c_result;
}

uint64_t SwigDirector_WrappedNamedArrayMemoryClientBuffer::GetBufferLength() {
  uint64_t c_result = SwigValueInit< uint64_t >() ;
  unsigned long long jresult = 0 ;
  
  if (!swig_callbackGetBufferLength) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedNamedArrayMemoryClientBuffer::GetBufferLength");
    return c_result;
  } else {
    jresult = (unsigned long long) swig_callbackGetBufferLength();
    c_result = (uint64_t)jresult; 
  }
  return c_result;
}

SwigDirector_WrappedNamedArrayMemoryClientBuffer::~SwigDirector_WrappedNamedArrayMemoryClientBuffer() {
  
}


void SwigDirector_WrappedNamedArrayMemoryClientBuffer::swig_connect_director(SWIG_Callback0_t callbackUnpackReadResult, SWIG_Callback1_t callbackPackWriteRequest, SWIG_Callback2_t callbackGetBufferLength) {
  swig_callbackUnpackReadResult = callbackUnpackReadResult;
  swig_callbackPackWriteRequest = callbackPackWriteRequest;
  swig_callbackGetBufferLength = callbackGetBufferLength;
}

void SwigDirector_WrappedNamedArrayMemoryClientBuffer::swig_init_callbacks() {
  swig_callbackUnpackReadResult = 0;
  swig_callbackPackWriteRequest = 0;
  swig_callbackGetBufferLength = 0;
}

SwigDirector_WrappedNamedMultiDimArrayMemoryClientBuffer::SwigDirector_WrappedNamedMultiDimArrayMemoryClientBuffer() : RobotRaconteur::WrappedNamedMultiDimArrayMemoryClientBuffer(), Swig::Director() {
  swig_init_callbacks();
}

void SwigDirector_WrappedNamedMultiDimArrayMemoryClientBuffer::UnpackReadResult(boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > res, std::vector< uint64_t > const &bufferpos, std::vector< uint64_t > const &count) {
  void * jres  ;
  void * jbufferpos = 0 ;
  void * jcount = 0 ;
  
  if (!swig_callbackUnpackReadResult) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedNamedMultiDimArrayMemoryClientBuffer::UnpackReadResult");
    return;
  } else {
    //jres = res ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< RobotRaconteur::MessageElementNestedElementList >(res) : 0;
    if (res) {
      intrusive_ptr_add_ref((&res)->get());
      *(boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > **)&jres = new boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList >((&res)->get(), SWIG_intrusive_deleter< RobotRaconteur::MessageElementNestedElementList >());
    } else {
      *(boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > **)&jres = 0;
    }
    
    jbufferpos = (std::vector< uint64_t > *) &bufferpos; 
    jcount = (std::vector< uint64_t > *) &count; 
    swig_callbackUnpackReadResult(jres, jbufferpos, jcount);
  }
}

boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > SwigDirector_WrappedNamedMultiDimArrayMemoryClientBuffer::PackWriteRequest(std::vector< uint64_t > const &bufferpos, std::vector< uint64_t > const &count) {
  boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > c_result ;
  void * jresult = 0 ;
  void * jbufferpos = 0 ;
  void * jcount = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > *smartarg ;
  
  if (!swig_callbackPackWriteRequest) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedNamedMultiDimArrayMemoryClientBuffer::PackWriteRequest");
    return c_result;
  } else {
    jbufferpos = (std::vector< uint64_t > *) &bufferpos; 
    jcount = (std::vector< uint64_t > *) &count; 
    jresult = (void *) swig_callbackPackWriteRequest(jbufferpos, jcount);
    
    //if (jresult) {
    //    SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST RobotRaconteur::MessageElementNestedElementList > *smartarg = (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST RobotRaconteur::MessageElementNestedElementList > *)jresult;
    //    c_result = *smartarg;
    //  }
    smartarg = *(boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList >**)&jresult;
    if (smartarg) {
      c_result = boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList >(smartarg->get(), true);
    }
    
    
  }
  return c_result;
}

SwigDirector_WrappedNamedMultiDimArrayMemoryClientBuffer::~SwigDirector_WrappedNamedMultiDimArrayMemoryClientBuffer() {
  
}


void SwigDirector_WrappedNamedMultiDimArrayMemoryClientBuffer::swig_connect_director(SWIG_Callback0_t callbackUnpackReadResult, SWIG_Callback1_t callbackPackWriteRequest) {
  swig_callbackUnpackReadResult = callbackUnpackReadResult;
  swig_callbackPackWriteRequest = callbackPackWriteRequest;
}

void SwigDirector_WrappedNamedMultiDimArrayMemoryClientBuffer::swig_init_callbacks() {
  swig_callbackUnpackReadResult = 0;
  swig_callbackPackWriteRequest = 0;
}

SwigDirector_WrappedNamedArrayMemoryDirector::SwigDirector_WrappedNamedArrayMemoryDirector() : RobotRaconteur::WrappedNamedArrayMemoryDirector(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_WrappedNamedArrayMemoryDirector::~SwigDirector_WrappedNamedArrayMemoryDirector() {
  
}


uint64_t SwigDirector_WrappedNamedArrayMemoryDirector::Length() {
  uint64_t c_result = SwigValueInit< uint64_t >() ;
  unsigned long long jresult = 0 ;
  
  if (!swig_callbackLength) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedNamedArrayMemoryDirector::Length");
    return c_result;
  } else {
    jresult = (unsigned long long) swig_callbackLength();
    c_result = (uint64_t)jresult; 
  }
  return c_result;
}

boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > SwigDirector_WrappedNamedArrayMemoryDirector::Read(uint64_t memorypos, uint64_t bufferpos, uint64_t count) {
  boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > c_result ;
  void * jresult = 0 ;
  unsigned long long jmemorypos  ;
  unsigned long long jbufferpos  ;
  unsigned long long jcount  ;
  boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > *smartarg ;
  
  if (!swig_callbackRead) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedNamedArrayMemoryDirector::Read");
    return c_result;
  } else {
    jmemorypos = memorypos;
    jbufferpos = bufferpos;
    jcount = count;
    jresult = (void *) swig_callbackRead(jmemorypos, jbufferpos, jcount);
    
    //if (jresult) {
    //    SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST RobotRaconteur::MessageElementNestedElementList > *smartarg = (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST RobotRaconteur::MessageElementNestedElementList > *)jresult;
    //    c_result = *smartarg;
    //  }
    smartarg = *(boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList >**)&jresult;
    if (smartarg) {
      c_result = boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList >(smartarg->get(), true);
    }
    
    
  }
  return c_result;
}

void SwigDirector_WrappedNamedArrayMemoryDirector::Write(uint64_t memorypos, boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > buffer, uint64_t bufferpos, uint64_t count) {
  unsigned long long jmemorypos  ;
  void * jbuffer  ;
  unsigned long long jbufferpos  ;
  unsigned long long jcount  ;
  
  if (!swig_callbackWrite) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedNamedArrayMemoryDirector::Write");
    return;
  } else {
    jmemorypos = memorypos;
    
    //jbuffer = buffer ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< RobotRaconteur::MessageElementNestedElementList >(buffer) : 0;
    if (buffer) {
      intrusive_ptr_add_ref((&buffer)->get());
      *(boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > **)&jbuffer = new boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList >((&buffer)->get(), SWIG_intrusive_deleter< RobotRaconteur::MessageElementNestedElementList >());
    } else {
      *(boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > **)&jbuffer = 0;
    }
    
    jbufferpos = bufferpos;
    jcount = count;
    swig_callbackWrite(jmemorypos, jbuffer, jbufferpos, jcount);
  }
}

void SwigDirector_WrappedNamedArrayMemoryDirector::swig_connect_director(SWIG_Callback0_t callbackLength, SWIG_Callback1_t callbackRead, SWIG_Callback2_t callbackWrite) {
  swig_callbackLength = callbackLength;
  swig_callbackRead = callbackRead;
  swig_callbackWrite = callbackWrite;
}

void SwigDirector_WrappedNamedArrayMemoryDirector::swig_init_callbacks() {
  swig_callbackLength = 0;
  swig_callbackRead = 0;
  swig_callbackWrite = 0;
}

SwigDirector_WrappedNamedMultiDimArrayMemoryDirector::SwigDirector_WrappedNamedMultiDimArrayMemoryDirector() : RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_WrappedNamedMultiDimArrayMemoryDirector::~SwigDirector_WrappedNamedMultiDimArrayMemoryDirector() {
  
}


std::vector< uint64_t > SwigDirector_WrappedNamedMultiDimArrayMemoryDirector::Dimensions() {
  std::vector< uint64_t > c_result ;
  void * jresult = 0 ;
  
  if (!swig_callbackDimensions) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector::Dimensions");
    return c_result;
  } else {
    jresult = (void *) swig_callbackDimensions();
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type std::vector< uint64_t >", 0);
      return c_result;
    }
    c_result = *(std::vector< uint64_t > *)jresult; 
  }
  return c_result;
}

uint64_t SwigDirector_WrappedNamedMultiDimArrayMemoryDirector::DimCount() {
  uint64_t c_result = SwigValueInit< uint64_t >() ;
  unsigned long long jresult = 0 ;
  
  if (!swig_callbackDimCount) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector::DimCount");
    return c_result;
  } else {
    jresult = (unsigned long long) swig_callbackDimCount();
    c_result = (uint64_t)jresult; 
  }
  return c_result;
}

boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > SwigDirector_WrappedNamedMultiDimArrayMemoryDirector::Read(std::vector< uint64_t > const &memorypos, std::vector< uint64_t > const &bufferpos, std::vector< uint64_t > const &count) {
  boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > c_result ;
  void * jresult = 0 ;
  void * jmemorypos = 0 ;
  void * jbufferpos = 0 ;
  void * jcount = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > *smartarg ;
  
  if (!swig_callbackRead) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector::Read");
    return c_result;
  } else {
    jmemorypos = (std::vector< uint64_t > *) &memorypos; 
    jbufferpos = (std::vector< uint64_t > *) &bufferpos; 
    jcount = (std::vector< uint64_t > *) &count; 
    jresult = (void *) swig_callbackRead(jmemorypos, jbufferpos, jcount);
    
    //if (jresult) {
    //    SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST RobotRaconteur::MessageElementNestedElementList > *smartarg = (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST RobotRaconteur::MessageElementNestedElementList > *)jresult;
    //    c_result = *smartarg;
    //  }
    smartarg = *(boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList >**)&jresult;
    if (smartarg) {
      c_result = boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList >(smartarg->get(), true);
    }
    
    
  }
  return c_result;
}

void SwigDirector_WrappedNamedMultiDimArrayMemoryDirector::Write(std::vector< uint64_t > const &memorypos, boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > buffer, std::vector< uint64_t > const &bufferpos, std::vector< uint64_t > const &count) {
  void * jmemorypos = 0 ;
  void * jbuffer  ;
  void * jbufferpos = 0 ;
  void * jcount = 0 ;
  
  if (!swig_callbackWrite) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector::Write");
    return;
  } else {
    jmemorypos = (std::vector< uint64_t > *) &memorypos; 
    
    //jbuffer = buffer ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< RobotRaconteur::MessageElementNestedElementList >(buffer) : 0;
    if (buffer) {
      intrusive_ptr_add_ref((&buffer)->get());
      *(boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > **)&jbuffer = new boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList >((&buffer)->get(), SWIG_intrusive_deleter< RobotRaconteur::MessageElementNestedElementList >());
    } else {
      *(boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > **)&jbuffer = 0;
    }
    
    jbufferpos = (std::vector< uint64_t > *) &bufferpos; 
    jcount = (std::vector< uint64_t > *) &count; 
    swig_callbackWrite(jmemorypos, jbuffer, jbufferpos, jcount);
  }
}

void SwigDirector_WrappedNamedMultiDimArrayMemoryDirector::swig_connect_director(SWIG_Callback0_t callbackDimensions, SWIG_Callback1_t callbackDimCount, SWIG_Callback2_t callbackRead, SWIG_Callback3_t callbackWrite) {
  swig_callbackDimensions = callbackDimensions;
  swig_callbackDimCount = callbackDimCount;
  swig_callbackRead = callbackRead;
  swig_callbackWrite = callbackWrite;
}

void SwigDirector_WrappedNamedMultiDimArrayMemoryDirector::swig_init_callbacks() {
  swig_callbackDimensions = 0;
  swig_callbackDimCount = 0;
  swig_callbackRead = 0;
  swig_callbackWrite = 0;
}

SwigDirector_AsyncGeneratorClientReturnDirector::SwigDirector_AsyncGeneratorClientReturnDirector() : RobotRaconteur::AsyncGeneratorClientReturnDirector(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_AsyncGeneratorClientReturnDirector::~SwigDirector_AsyncGeneratorClientReturnDirector() {
  
}


void SwigDirector_AsyncGeneratorClientReturnDirector::handler(boost::shared_ptr< RobotRaconteur::WrappedGeneratorClient > const &ret, RobotRaconteur::HandlerErrorInfo &error) {
  void * jret = 0 ;
  void * jerror = 0 ;
  
  if (!swig_callbackhandler) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::AsyncGeneratorClientReturnDirector::handler");
    return;
  } else {
    jret = ret ? new boost::shared_ptr<  RobotRaconteur::WrappedGeneratorClient >(ret) : 0; 
    jerror = (RobotRaconteur::HandlerErrorInfo *) &error; 
    swig_callbackhandler(jret, jerror);
  }
}

void SwigDirector_AsyncGeneratorClientReturnDirector::swig_connect_director(SWIG_Callback0_t callbackhandler) {
  swig_callbackhandler = callbackhandler;
}

void SwigDirector_AsyncGeneratorClientReturnDirector::swig_init_callbacks() {
  swig_callbackhandler = 0;
}

SwigDirector_WrappedGeneratorServerDirector::SwigDirector_WrappedGeneratorServerDirector() : RobotRaconteur::WrappedGeneratorServerDirector(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_WrappedGeneratorServerDirector::~SwigDirector_WrappedGeneratorServerDirector() {
  
}


boost::intrusive_ptr< RobotRaconteur::MessageElement > SwigDirector_WrappedGeneratorServerDirector::Next(boost::intrusive_ptr< RobotRaconteur::MessageElement > m, boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > const &async_adaptor) {
  boost::intrusive_ptr< RobotRaconteur::MessageElement > c_result ;
  void * jresult = 0 ;
  void * jm  ;
  void * jasync_adaptor = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg ;
  
  if (!swig_callbackNext) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedGeneratorServerDirector::Next");
    return c_result;
  } else {
    //jm = m ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< RobotRaconteur::MessageElement >(m) : 0;
    if (m) {
      intrusive_ptr_add_ref((&m)->get());
      *(boost::shared_ptr< RobotRaconteur::MessageElement > **)&jm = new boost::shared_ptr< RobotRaconteur::MessageElement >((&m)->get(), SWIG_intrusive_deleter< RobotRaconteur::MessageElement >());
    } else {
      *(boost::shared_ptr< RobotRaconteur::MessageElement > **)&jm = 0;
    }
    
    jasync_adaptor = async_adaptor ? new boost::shared_ptr<  RobotRaconteur::WrappedServiceSkelAsyncAdapter >(async_adaptor) : 0; 
    jresult = (void *) swig_callbackNext(jm, jasync_adaptor);
    
    //if (jresult) {
    //    SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST RobotRaconteur::MessageElement > *smartarg = (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST RobotRaconteur::MessageElement > *)jresult;
    //    c_result = *smartarg;
    //  }
    smartarg = *(boost::shared_ptr< RobotRaconteur::MessageElement >**)&jresult;
    if (smartarg) {
      c_result = boost::intrusive_ptr< RobotRaconteur::MessageElement >(smartarg->get(), true);
    }
    
    
  }
  return c_result;
}

void SwigDirector_WrappedGeneratorServerDirector::Abort(boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > const &async_adapter) {
  void * jasync_adapter = 0 ;
  
  if (!swig_callbackAbort) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedGeneratorServerDirector::Abort");
    return;
  } else {
    jasync_adapter = async_adapter ? new boost::shared_ptr<  RobotRaconteur::WrappedServiceSkelAsyncAdapter >(async_adapter) : 0; 
    swig_callbackAbort(jasync_adapter);
  }
}

void SwigDirector_WrappedGeneratorServerDirector::Close(boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > const &async_adapter) {
  void * jasync_adapter = 0 ;
  
  if (!swig_callbackClose) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedGeneratorServerDirector::Close");
    return;
  } else {
    jasync_adapter = async_adapter ? new boost::shared_ptr<  RobotRaconteur::WrappedServiceSkelAsyncAdapter >(async_adapter) : 0; 
    swig_callbackClose(jasync_adapter);
  }
}

void SwigDirector_WrappedGeneratorServerDirector::swig_connect_director(SWIG_Callback0_t callbackNext, SWIG_Callback1_t callbackAbort, SWIG_Callback2_t callbackClose) {
  swig_callbackNext = callbackNext;
  swig_callbackAbort = callbackAbort;
  swig_callbackClose = callbackClose;
}

void SwigDirector_WrappedGeneratorServerDirector::swig_init_callbacks() {
  swig_callbackNext = 0;
  swig_callbackAbort = 0;
  swig_callbackClose = 0;
}

SwigDirector_WrappedServiceStubDirector::SwigDirector_WrappedServiceStubDirector() : RobotRaconteur::WrappedServiceStubDirector(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_WrappedServiceStubDirector::~SwigDirector_WrappedServiceStubDirector() {
  
}


void SwigDirector_WrappedServiceStubDirector::DispatchEvent(std::string const &EventName, std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > args) {
  char * jEventName = 0 ;
  void * jargs  ;
  
  if (!swig_callbackDispatchEvent) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedServiceStubDirector::DispatchEvent");
    return;
  } else {
    jEventName = SWIG_csharp_string_callback((&EventName)->c_str()); 
    jargs = (void *)new std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > >((const std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > &)args); 
    swig_callbackDispatchEvent(jEventName, jargs);
  }
}

boost::intrusive_ptr< RobotRaconteur::MessageElement > SwigDirector_WrappedServiceStubDirector::CallbackCall(std::string const &CallbackName, std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > args) {
  boost::intrusive_ptr< RobotRaconteur::MessageElement > c_result ;
  void * jresult = 0 ;
  char * jCallbackName = 0 ;
  void * jargs  ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg ;
  
  if (!swig_callbackCallbackCall) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedServiceStubDirector::CallbackCall");
    return c_result;
  } else {
    jCallbackName = SWIG_csharp_string_callback((&CallbackName)->c_str()); 
    jargs = (void *)new std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > >((const std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > &)args); 
    jresult = (void *) swig_callbackCallbackCall(jCallbackName, jargs);
    
    //if (jresult) {
    //    SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST RobotRaconteur::MessageElement > *smartarg = (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST RobotRaconteur::MessageElement > *)jresult;
    //    c_result = *smartarg;
    //  }
    smartarg = *(boost::shared_ptr< RobotRaconteur::MessageElement >**)&jresult;
    if (smartarg) {
      c_result = boost::intrusive_ptr< RobotRaconteur::MessageElement >(smartarg->get(), true);
    }
    
    
  }
  return c_result;
}

void SwigDirector_WrappedServiceStubDirector::swig_connect_director(SWIG_Callback0_t callbackDispatchEvent, SWIG_Callback1_t callbackCallbackCall) {
  swig_callbackDispatchEvent = callbackDispatchEvent;
  swig_callbackCallbackCall = callbackCallbackCall;
}

void SwigDirector_WrappedServiceStubDirector::swig_init_callbacks() {
  swig_callbackDispatchEvent = 0;
  swig_callbackCallbackCall = 0;
}

SwigDirector_AsyncStubReturnDirector::SwigDirector_AsyncStubReturnDirector() : RobotRaconteur::AsyncStubReturnDirector(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_AsyncStubReturnDirector::~SwigDirector_AsyncStubReturnDirector() {
  
}


void SwigDirector_AsyncStubReturnDirector::handler(boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &stub, RobotRaconteur::HandlerErrorInfo &error) {
  void * jstub = 0 ;
  void * jerror = 0 ;
  
  if (!swig_callbackhandler) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::AsyncStubReturnDirector::handler");
    return;
  } else {
    jstub = stub ? new boost::shared_ptr<  RobotRaconteur::WrappedServiceStub >(stub) : 0; 
    jerror = (RobotRaconteur::HandlerErrorInfo *) &error; 
    swig_callbackhandler(jstub, jerror);
  }
}

void SwigDirector_AsyncStubReturnDirector::swig_connect_director(SWIG_Callback0_t callbackhandler) {
  swig_callbackhandler = callbackhandler;
}

void SwigDirector_AsyncStubReturnDirector::swig_init_callbacks() {
  swig_callbackhandler = 0;
}

SwigDirector_WrappedServiceSkelDirector::SwigDirector_WrappedServiceSkelDirector() : RobotRaconteur::WrappedServiceSkelDirector(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_WrappedServiceSkelDirector::~SwigDirector_WrappedServiceSkelDirector() {
  
}


void SwigDirector_WrappedServiceSkelDirector::Init(boost::shared_ptr< RobotRaconteur::WrappedServiceSkel > const &skel) {
  void * jskel = 0 ;
  
  if (!swig_callbackInit) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedServiceSkelDirector::Init");
    return;
  } else {
    jskel = skel ? new boost::shared_ptr<  RobotRaconteur::WrappedServiceSkel >(skel) : 0; 
    swig_callbackInit(jskel);
  }
}

boost::intrusive_ptr< RobotRaconteur::MessageElement > SwigDirector_WrappedServiceSkelDirector::CallGetProperty(std::string const &name, boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > const &async_adaptor) {
  boost::intrusive_ptr< RobotRaconteur::MessageElement > c_result ;
  void * jresult = 0 ;
  char * jname = 0 ;
  void * jasync_adaptor = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg ;
  
  if (!swig_callback_CallGetProperty) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedServiceSkelDirector::CallGetProperty");
    return c_result;
  } else {
    jname = SWIG_csharp_string_callback((&name)->c_str()); 
    jasync_adaptor = async_adaptor ? new boost::shared_ptr<  RobotRaconteur::WrappedServiceSkelAsyncAdapter >(async_adaptor) : 0; 
    jresult = (void *) swig_callback_CallGetProperty(jname, jasync_adaptor);
    
    //if (jresult) {
    //    SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST RobotRaconteur::MessageElement > *smartarg = (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST RobotRaconteur::MessageElement > *)jresult;
    //    c_result = *smartarg;
    //  }
    smartarg = *(boost::shared_ptr< RobotRaconteur::MessageElement >**)&jresult;
    if (smartarg) {
      c_result = boost::intrusive_ptr< RobotRaconteur::MessageElement >(smartarg->get(), true);
    }
    
    
  }
  return c_result;
}

void SwigDirector_WrappedServiceSkelDirector::CallSetProperty(std::string const &name, boost::intrusive_ptr< RobotRaconteur::MessageElement > m, boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > const &async_adaptor) {
  char * jname = 0 ;
  void * jm  ;
  void * jasync_adaptor = 0 ;
  
  if (!swig_callback_CallSetProperty) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedServiceSkelDirector::CallSetProperty");
    return;
  } else {
    jname = SWIG_csharp_string_callback((&name)->c_str()); 
    
    //jm = m ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< RobotRaconteur::MessageElement >(m) : 0;
    if (m) {
      intrusive_ptr_add_ref((&m)->get());
      *(boost::shared_ptr< RobotRaconteur::MessageElement > **)&jm = new boost::shared_ptr< RobotRaconteur::MessageElement >((&m)->get(), SWIG_intrusive_deleter< RobotRaconteur::MessageElement >());
    } else {
      *(boost::shared_ptr< RobotRaconteur::MessageElement > **)&jm = 0;
    }
    
    jasync_adaptor = async_adaptor ? new boost::shared_ptr<  RobotRaconteur::WrappedServiceSkelAsyncAdapter >(async_adaptor) : 0; 
    swig_callback_CallSetProperty(jname, jm, jasync_adaptor);
  }
}

boost::intrusive_ptr< RobotRaconteur::MessageElement > SwigDirector_WrappedServiceSkelDirector::CallFunction(std::string const &name, std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > const &m, boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > const &async_adaptor) {
  boost::intrusive_ptr< RobotRaconteur::MessageElement > c_result ;
  void * jresult = 0 ;
  char * jname = 0 ;
  void * jm = 0 ;
  void * jasync_adaptor = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg ;
  
  if (!swig_callback_CallFunction) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedServiceSkelDirector::CallFunction");
    return c_result;
  } else {
    jname = SWIG_csharp_string_callback((&name)->c_str()); 
    jm = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *) &m; 
    jasync_adaptor = async_adaptor ? new boost::shared_ptr<  RobotRaconteur::WrappedServiceSkelAsyncAdapter >(async_adaptor) : 0; 
    jresult = (void *) swig_callback_CallFunction(jname, jm, jasync_adaptor);
    
    //if (jresult) {
    //    SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST RobotRaconteur::MessageElement > *smartarg = (SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST RobotRaconteur::MessageElement > *)jresult;
    //    c_result = *smartarg;
    //  }
    smartarg = *(boost::shared_ptr< RobotRaconteur::MessageElement >**)&jresult;
    if (smartarg) {
      c_result = boost::intrusive_ptr< RobotRaconteur::MessageElement >(smartarg->get(), true);
    }
    
    
  }
  return c_result;
}

boost::shared_ptr< RobotRaconteur::WrappedRRObject > SwigDirector_WrappedServiceSkelDirector::GetSubObj(std::string const &name, std::string const &index) {
  boost::shared_ptr< RobotRaconteur::WrappedRRObject > c_result ;
  void * jresult = 0 ;
  char * jname = 0 ;
  char * jindex = 0 ;
  
  if (!swig_callback_GetSubObj) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedServiceSkelDirector::GetSubObj");
    return c_result;
  } else {
    jname = SWIG_csharp_string_callback((&name)->c_str()); 
    jindex = SWIG_csharp_string_callback((&index)->c_str()); 
    jresult = (void *) swig_callback_GetSubObj(jname, jindex);
    if (jresult) {
      boost::shared_ptr<  RobotRaconteur::WrappedRRObject > *smartarg = (boost::shared_ptr<  RobotRaconteur::WrappedRRObject > *)jresult;
      c_result = *smartarg;
    }
    
  }
  return c_result;
}

RobotRaconteur::WrappedArrayMemoryDirector *SwigDirector_WrappedServiceSkelDirector::GetArrayMemory(std::string const &name) {
  RobotRaconteur::WrappedArrayMemoryDirector *c_result = 0 ;
  void * jresult = 0 ;
  char * jname = 0 ;
  
  if (!swig_callback_GetArrayMemory) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedServiceSkelDirector::GetArrayMemory");
    return c_result;
  } else {
    jname = SWIG_csharp_string_callback((&name)->c_str()); 
    jresult = (void *) swig_callback_GetArrayMemory(jname);
    c_result = (RobotRaconteur::WrappedArrayMemoryDirector *)jresult; 
  }
  return c_result;
}

RobotRaconteur::WrappedMultiDimArrayMemoryDirector *SwigDirector_WrappedServiceSkelDirector::GetMultiDimArrayMemory(std::string const &name) {
  RobotRaconteur::WrappedMultiDimArrayMemoryDirector *c_result = 0 ;
  void * jresult = 0 ;
  char * jname = 0 ;
  
  if (!swig_callback_GetMultiDimArrayMemory) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedServiceSkelDirector::GetMultiDimArrayMemory");
    return c_result;
  } else {
    jname = SWIG_csharp_string_callback((&name)->c_str()); 
    jresult = (void *) swig_callback_GetMultiDimArrayMemory(jname);
    c_result = (RobotRaconteur::WrappedMultiDimArrayMemoryDirector *)jresult; 
  }
  return c_result;
}

RobotRaconteur::WrappedPodArrayMemoryDirector *SwigDirector_WrappedServiceSkelDirector::GetPodArrayMemory(std::string const &name) {
  RobotRaconteur::WrappedPodArrayMemoryDirector *c_result = 0 ;
  void * jresult = 0 ;
  char * jname = 0 ;
  
  if (!swig_callback_GetPodArrayMemory) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedServiceSkelDirector::GetPodArrayMemory");
    return c_result;
  } else {
    jname = SWIG_csharp_string_callback((&name)->c_str()); 
    jresult = (void *) swig_callback_GetPodArrayMemory(jname);
    c_result = (RobotRaconteur::WrappedPodArrayMemoryDirector *)jresult; 
  }
  return c_result;
}

RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector *SwigDirector_WrappedServiceSkelDirector::GetPodMultiDimArrayMemory(std::string const &name) {
  RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector *c_result = 0 ;
  void * jresult = 0 ;
  char * jname = 0 ;
  
  if (!swig_callback_GetPodMultiDimArrayMemory) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedServiceSkelDirector::GetPodMultiDimArrayMemory");
    return c_result;
  } else {
    jname = SWIG_csharp_string_callback((&name)->c_str()); 
    jresult = (void *) swig_callback_GetPodMultiDimArrayMemory(jname);
    c_result = (RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector *)jresult; 
  }
  return c_result;
}

RobotRaconteur::WrappedNamedArrayMemoryDirector *SwigDirector_WrappedServiceSkelDirector::GetNamedArrayMemory(std::string const &name) {
  RobotRaconteur::WrappedNamedArrayMemoryDirector *c_result = 0 ;
  void * jresult = 0 ;
  char * jname = 0 ;
  
  if (!swig_callback_GetNamedArrayMemory) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedServiceSkelDirector::GetNamedArrayMemory");
    return c_result;
  } else {
    jname = SWIG_csharp_string_callback((&name)->c_str()); 
    jresult = (void *) swig_callback_GetNamedArrayMemory(jname);
    c_result = (RobotRaconteur::WrappedNamedArrayMemoryDirector *)jresult; 
  }
  return c_result;
}

RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector *SwigDirector_WrappedServiceSkelDirector::GetNamedMultiDimArrayMemory(std::string const &name) {
  RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector *c_result = 0 ;
  void * jresult = 0 ;
  char * jname = 0 ;
  
  if (!swig_callback_GetNamedMultiDimArrayMemory) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedServiceSkelDirector::GetNamedMultiDimArrayMemory");
    return c_result;
  } else {
    jname = SWIG_csharp_string_callback((&name)->c_str()); 
    jresult = (void *) swig_callback_GetNamedMultiDimArrayMemory(jname);
    c_result = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector *)jresult; 
  }
  return c_result;
}

void SwigDirector_WrappedServiceSkelDirector::MonitorEnter(int32_t timeout) {
  int jtimeout  ;
  
  if (!swig_callbackMonitorEnter) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedServiceSkelDirector::MonitorEnter");
    return;
  } else {
    jtimeout = timeout;
    swig_callbackMonitorEnter(jtimeout);
  }
}

void SwigDirector_WrappedServiceSkelDirector::MonitorExit() {
  if (!swig_callbackMonitorExit) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedServiceSkelDirector::MonitorExit");
    return;
  } else {
    swig_callbackMonitorExit();
  }
}

void SwigDirector_WrappedServiceSkelDirector::ReleaseCastObject() {
  if (!swig_callbackReleaseCastObject) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedServiceSkelDirector::ReleaseCastObject");
    return;
  } else {
    swig_callbackReleaseCastObject();
  }
}

void SwigDirector_WrappedServiceSkelDirector::swig_connect_director(SWIG_Callback0_t callbackInit, SWIG_Callback1_t callback_CallGetProperty, SWIG_Callback2_t callback_CallSetProperty, SWIG_Callback3_t callback_CallFunction, SWIG_Callback4_t callback_GetSubObj, SWIG_Callback5_t callback_GetArrayMemory, SWIG_Callback6_t callback_GetMultiDimArrayMemory, SWIG_Callback7_t callback_GetPodArrayMemory, SWIG_Callback8_t callback_GetPodMultiDimArrayMemory, SWIG_Callback9_t callback_GetNamedArrayMemory, SWIG_Callback10_t callback_GetNamedMultiDimArrayMemory, SWIG_Callback11_t callbackMonitorEnter, SWIG_Callback12_t callbackMonitorExit, SWIG_Callback13_t callbackReleaseCastObject) {
  swig_callbackInit = callbackInit;
  swig_callback_CallGetProperty = callback_CallGetProperty;
  swig_callback_CallSetProperty = callback_CallSetProperty;
  swig_callback_CallFunction = callback_CallFunction;
  swig_callback_GetSubObj = callback_GetSubObj;
  swig_callback_GetArrayMemory = callback_GetArrayMemory;
  swig_callback_GetMultiDimArrayMemory = callback_GetMultiDimArrayMemory;
  swig_callback_GetPodArrayMemory = callback_GetPodArrayMemory;
  swig_callback_GetPodMultiDimArrayMemory = callback_GetPodMultiDimArrayMemory;
  swig_callback_GetNamedArrayMemory = callback_GetNamedArrayMemory;
  swig_callback_GetNamedMultiDimArrayMemory = callback_GetNamedMultiDimArrayMemory;
  swig_callbackMonitorEnter = callbackMonitorEnter;
  swig_callbackMonitorExit = callbackMonitorExit;
  swig_callbackReleaseCastObject = callbackReleaseCastObject;
}

void SwigDirector_WrappedServiceSkelDirector::swig_init_callbacks() {
  swig_callbackInit = 0;
  swig_callback_CallGetProperty = 0;
  swig_callback_CallSetProperty = 0;
  swig_callback_CallFunction = 0;
  swig_callback_GetSubObj = 0;
  swig_callback_GetArrayMemory = 0;
  swig_callback_GetMultiDimArrayMemory = 0;
  swig_callback_GetPodArrayMemory = 0;
  swig_callback_GetPodMultiDimArrayMemory = 0;
  swig_callback_GetNamedArrayMemory = 0;
  swig_callback_GetNamedMultiDimArrayMemory = 0;
  swig_callbackMonitorEnter = 0;
  swig_callbackMonitorExit = 0;
  swig_callbackReleaseCastObject = 0;
}

SwigDirector_ServerServiceListenerDirector::SwigDirector_ServerServiceListenerDirector() : ServerServiceListenerDirector(), Swig::Director() {
  swig_init_callbacks();
}

void SwigDirector_ServerServiceListenerDirector::Callback(int32_t code, uint32_t endpoint) {
  int jcode  ;
  unsigned int jendpoint  ;
  
  if (!swig_callbackCallback) {
    ServerServiceListenerDirector::Callback(code,endpoint);
    return;
  } else {
    jcode = code;
    jendpoint = endpoint;
    swig_callbackCallback(jcode, jendpoint);
  }
}

SwigDirector_ServerServiceListenerDirector::~SwigDirector_ServerServiceListenerDirector() {
  
}


void SwigDirector_ServerServiceListenerDirector::swig_connect_director(SWIG_Callback0_t callbackCallback) {
  swig_callbackCallback = callbackCallback;
}

void SwigDirector_ServerServiceListenerDirector::swig_init_callbacks() {
  swig_callbackCallback = 0;
}

SwigDirector_WrappedUserAuthenticatorDirector::SwigDirector_WrappedUserAuthenticatorDirector() : RobotRaconteur::WrappedUserAuthenticatorDirector(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_WrappedUserAuthenticatorDirector::~SwigDirector_WrappedUserAuthenticatorDirector() {
  
}


boost::shared_ptr< RobotRaconteur::AuthenticatedUser > SwigDirector_WrappedUserAuthenticatorDirector::AuthenticateUser(std::string const &username, boost::intrusive_ptr< RobotRaconteur::MessageElement > credentials, boost::shared_ptr< RobotRaconteur::ServerContext > const &context) {
  boost::shared_ptr< RobotRaconteur::AuthenticatedUser > c_result ;
  void * jresult = 0 ;
  char * jusername = 0 ;
  void * jcredentials  ;
  void * jcontext = 0 ;
  
  if (!swig_callbackAuthenticateUser) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedUserAuthenticatorDirector::AuthenticateUser");
    return c_result;
  } else {
    jusername = SWIG_csharp_string_callback((&username)->c_str()); 
    
    //jcredentials = credentials ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< RobotRaconteur::MessageElement >(credentials) : 0;
    if (credentials) {
      intrusive_ptr_add_ref((&credentials)->get());
      *(boost::shared_ptr< RobotRaconteur::MessageElement > **)&jcredentials = new boost::shared_ptr< RobotRaconteur::MessageElement >((&credentials)->get(), SWIG_intrusive_deleter< RobotRaconteur::MessageElement >());
    } else {
      *(boost::shared_ptr< RobotRaconteur::MessageElement > **)&jcredentials = 0;
    }
    
    jcontext = context ? new boost::shared_ptr<  RobotRaconteur::ServerContext >(context) : 0; 
    jresult = (void *) swig_callbackAuthenticateUser(jusername, jcredentials, jcontext);
    if (jresult) {
      boost::shared_ptr<  RobotRaconteur::AuthenticatedUser > *smartarg = (boost::shared_ptr<  RobotRaconteur::AuthenticatedUser > *)jresult;
      c_result = *smartarg;
    }
    
  }
  return c_result;
}

void SwigDirector_WrappedUserAuthenticatorDirector::swig_connect_director(SWIG_Callback0_t callbackAuthenticateUser) {
  swig_callbackAuthenticateUser = callbackAuthenticateUser;
}

void SwigDirector_WrappedUserAuthenticatorDirector::swig_init_callbacks() {
  swig_callbackAuthenticateUser = 0;
}

SwigDirector_AsyncServiceInfo2VectorReturnDirector::SwigDirector_AsyncServiceInfo2VectorReturnDirector() : RobotRaconteur::AsyncServiceInfo2VectorReturnDirector(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_AsyncServiceInfo2VectorReturnDirector::~SwigDirector_AsyncServiceInfo2VectorReturnDirector() {
  
}


void SwigDirector_AsyncServiceInfo2VectorReturnDirector::handler(std::vector< RobotRaconteur::ServiceInfo2Wrapped > const &ret) {
  void * jret = 0 ;
  
  if (!swig_callbackhandler) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::AsyncServiceInfo2VectorReturnDirector::handler");
    return;
  } else {
    jret = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *) &ret; 
    swig_callbackhandler(jret);
  }
}

void SwigDirector_AsyncServiceInfo2VectorReturnDirector::swig_connect_director(SWIG_Callback0_t callbackhandler) {
  swig_callbackhandler = callbackhandler;
}

void SwigDirector_AsyncServiceInfo2VectorReturnDirector::swig_init_callbacks() {
  swig_callbackhandler = 0;
}

SwigDirector_AsyncNodeInfo2VectorReturnDirector::SwigDirector_AsyncNodeInfo2VectorReturnDirector() : RobotRaconteur::AsyncNodeInfo2VectorReturnDirector(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_AsyncNodeInfo2VectorReturnDirector::~SwigDirector_AsyncNodeInfo2VectorReturnDirector() {
  
}


void SwigDirector_AsyncNodeInfo2VectorReturnDirector::handler(std::vector< RobotRaconteur::NodeInfo2 > const &ret) {
  void * jret = 0 ;
  
  if (!swig_callbackhandler) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::AsyncNodeInfo2VectorReturnDirector::handler");
    return;
  } else {
    jret = (std::vector< RobotRaconteur::NodeInfo2 > *) &ret; 
    swig_callbackhandler(jret);
  }
}

void SwigDirector_AsyncNodeInfo2VectorReturnDirector::swig_connect_director(SWIG_Callback0_t callbackhandler) {
  swig_callbackhandler = callbackhandler;
}

void SwigDirector_AsyncNodeInfo2VectorReturnDirector::swig_init_callbacks() {
  swig_callbackhandler = 0;
}

SwigDirector_WrappedServiceSubscriptionFilterPredicateDirector::SwigDirector_WrappedServiceSubscriptionFilterPredicateDirector() : RobotRaconteur::WrappedServiceSubscriptionFilterPredicateDirector(), Swig::Director() {
  swig_init_callbacks();
}

bool SwigDirector_WrappedServiceSubscriptionFilterPredicateDirector::Predicate(RobotRaconteur::ServiceInfo2Wrapped const &info) {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  void * jinfo = 0 ;
  
  if (!swig_callbackPredicate) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedServiceSubscriptionFilterPredicateDirector::Predicate");
    return c_result;
  } else {
    jinfo = (RobotRaconteur::ServiceInfo2Wrapped *) &info; 
    jresult = (unsigned int) swig_callbackPredicate(jinfo);
    c_result = jresult ? true : false; 
  }
  return c_result;
}

SwigDirector_WrappedServiceSubscriptionFilterPredicateDirector::~SwigDirector_WrappedServiceSubscriptionFilterPredicateDirector() {
  
}


void SwigDirector_WrappedServiceSubscriptionFilterPredicateDirector::swig_connect_director(SWIG_Callback0_t callbackPredicate) {
  swig_callbackPredicate = callbackPredicate;
}

void SwigDirector_WrappedServiceSubscriptionFilterPredicateDirector::swig_init_callbacks() {
  swig_callbackPredicate = 0;
}

SwigDirector_WrappedServiceInfo2SubscriptionDirector::SwigDirector_WrappedServiceInfo2SubscriptionDirector() : RobotRaconteur::WrappedServiceInfo2SubscriptionDirector(), Swig::Director() {
  swig_init_callbacks();
}

void SwigDirector_WrappedServiceInfo2SubscriptionDirector::ServiceDetected(boost::shared_ptr< RobotRaconteur::WrappedServiceInfo2Subscription > const &subscription, RobotRaconteur::ServiceSubscriptionClientID const &id, RobotRaconteur::ServiceInfo2Wrapped const &service) {
  void * jsubscription = 0 ;
  void * jid = 0 ;
  void * jservice = 0 ;
  
  if (!swig_callbackServiceDetected) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedServiceInfo2SubscriptionDirector::ServiceDetected");
    return;
  } else {
    jsubscription = subscription ? new boost::shared_ptr<  RobotRaconteur::WrappedServiceInfo2Subscription >(subscription) : 0; 
    jid = (RobotRaconteur::ServiceSubscriptionClientID *) &id; 
    jservice = (RobotRaconteur::ServiceInfo2Wrapped *) &service; 
    swig_callbackServiceDetected(jsubscription, jid, jservice);
  }
}

void SwigDirector_WrappedServiceInfo2SubscriptionDirector::ServiceLost(boost::shared_ptr< RobotRaconteur::WrappedServiceInfo2Subscription > const &subscription, RobotRaconteur::ServiceSubscriptionClientID const &id, RobotRaconteur::ServiceInfo2Wrapped const &service) {
  void * jsubscription = 0 ;
  void * jid = 0 ;
  void * jservice = 0 ;
  
  if (!swig_callbackServiceLost) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedServiceInfo2SubscriptionDirector::ServiceLost");
    return;
  } else {
    jsubscription = subscription ? new boost::shared_ptr<  RobotRaconteur::WrappedServiceInfo2Subscription >(subscription) : 0; 
    jid = (RobotRaconteur::ServiceSubscriptionClientID *) &id; 
    jservice = (RobotRaconteur::ServiceInfo2Wrapped *) &service; 
    swig_callbackServiceLost(jsubscription, jid, jservice);
  }
}

SwigDirector_WrappedServiceInfo2SubscriptionDirector::~SwigDirector_WrappedServiceInfo2SubscriptionDirector() {
  
}


void SwigDirector_WrappedServiceInfo2SubscriptionDirector::swig_connect_director(SWIG_Callback0_t callbackServiceDetected, SWIG_Callback1_t callbackServiceLost) {
  swig_callbackServiceDetected = callbackServiceDetected;
  swig_callbackServiceLost = callbackServiceLost;
}

void SwigDirector_WrappedServiceInfo2SubscriptionDirector::swig_init_callbacks() {
  swig_callbackServiceDetected = 0;
  swig_callbackServiceLost = 0;
}

SwigDirector_WrappedServiceSubscriptionDirector::SwigDirector_WrappedServiceSubscriptionDirector() : RobotRaconteur::WrappedServiceSubscriptionDirector(), Swig::Director() {
  swig_init_callbacks();
}

void SwigDirector_WrappedServiceSubscriptionDirector::ClientConnected(boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > const &subscription, RobotRaconteur::ServiceSubscriptionClientID const &id, boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &silent) {
  void * jsubscription = 0 ;
  void * jid = 0 ;
  void * jsilent = 0 ;
  
  if (!swig_callbackClientConnected) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedServiceSubscriptionDirector::ClientConnected");
    return;
  } else {
    jsubscription = subscription ? new boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription >(subscription) : 0; 
    jid = (RobotRaconteur::ServiceSubscriptionClientID *) &id; 
    jsilent = silent ? new boost::shared_ptr<  RobotRaconteur::WrappedServiceStub >(silent) : 0; 
    swig_callbackClientConnected(jsubscription, jid, jsilent);
  }
}

void SwigDirector_WrappedServiceSubscriptionDirector::ClientDisconnected(boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > const &subscription, RobotRaconteur::ServiceSubscriptionClientID const &id, boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &silent) {
  void * jsubscription = 0 ;
  void * jid = 0 ;
  void * jsilent = 0 ;
  
  if (!swig_callbackClientDisconnected) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedServiceSubscriptionDirector::ClientDisconnected");
    return;
  } else {
    jsubscription = subscription ? new boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription >(subscription) : 0; 
    jid = (RobotRaconteur::ServiceSubscriptionClientID *) &id; 
    jsilent = silent ? new boost::shared_ptr<  RobotRaconteur::WrappedServiceStub >(silent) : 0; 
    swig_callbackClientDisconnected(jsubscription, jid, jsilent);
  }
}

void SwigDirector_WrappedServiceSubscriptionDirector::ClientConnectFailed(boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > const &subscription, RobotRaconteur::ServiceSubscriptionClientID const &id, std::vector< std::string > const &url, RobotRaconteur::HandlerErrorInfo &error) {
  void * jsubscription = 0 ;
  void * jid = 0 ;
  void * jurl = 0 ;
  void * jerror = 0 ;
  
  if (!swig_callbackClientConnectFailed) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedServiceSubscriptionDirector::ClientConnectFailed");
    return;
  } else {
    jsubscription = subscription ? new boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription >(subscription) : 0; 
    jid = (RobotRaconteur::ServiceSubscriptionClientID *) &id; 
    jurl = (std::vector< std::string > *) &url; 
    jerror = (RobotRaconteur::HandlerErrorInfo *) &error; 
    swig_callbackClientConnectFailed(jsubscription, jid, jurl, jerror);
  }
}

SwigDirector_WrappedServiceSubscriptionDirector::~SwigDirector_WrappedServiceSubscriptionDirector() {
  
}


void SwigDirector_WrappedServiceSubscriptionDirector::swig_connect_director(SWIG_Callback0_t callbackClientConnected, SWIG_Callback1_t callbackClientDisconnected, SWIG_Callback2_t callbackClientConnectFailed) {
  swig_callbackClientConnected = callbackClientConnected;
  swig_callbackClientDisconnected = callbackClientDisconnected;
  swig_callbackClientConnectFailed = callbackClientConnectFailed;
}

void SwigDirector_WrappedServiceSubscriptionDirector::swig_init_callbacks() {
  swig_callbackClientConnected = 0;
  swig_callbackClientDisconnected = 0;
  swig_callbackClientConnectFailed = 0;
}

SwigDirector_WrappedWireSubscriptionDirector::SwigDirector_WrappedWireSubscriptionDirector() : RobotRaconteur::WrappedWireSubscriptionDirector(), Swig::Director() {
  swig_init_callbacks();
}

void SwigDirector_WrappedWireSubscriptionDirector::WireValueChanged(boost::shared_ptr< RobotRaconteur::WrappedWireSubscription > const &wire_subscription, RobotRaconteur::WrappedService_typed_packet &value, RobotRaconteur::TimeSpec const &time) {
  void * jwire_subscription = 0 ;
  void * jvalue = 0 ;
  void * jtime = 0 ;
  
  if (!swig_callbackWireValueChanged) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedWireSubscriptionDirector::WireValueChanged");
    return;
  } else {
    jwire_subscription = wire_subscription ? new boost::shared_ptr<  RobotRaconteur::WrappedWireSubscription >(wire_subscription) : 0; 
    jvalue = (RobotRaconteur::WrappedService_typed_packet *) &value; 
    jtime = (RobotRaconteur::TimeSpec *) &time; 
    swig_callbackWireValueChanged(jwire_subscription, jvalue, jtime);
  }
}

SwigDirector_WrappedWireSubscriptionDirector::~SwigDirector_WrappedWireSubscriptionDirector() {
  
}


void SwigDirector_WrappedWireSubscriptionDirector::swig_connect_director(SWIG_Callback0_t callbackWireValueChanged) {
  swig_callbackWireValueChanged = callbackWireValueChanged;
}

void SwigDirector_WrappedWireSubscriptionDirector::swig_init_callbacks() {
  swig_callbackWireValueChanged = 0;
}

SwigDirector_WrappedPipeSubscriptionDirector::SwigDirector_WrappedPipeSubscriptionDirector() : RobotRaconteur::WrappedPipeSubscriptionDirector(), Swig::Director() {
  swig_init_callbacks();
}

void SwigDirector_WrappedPipeSubscriptionDirector::PipePacketReceived(boost::shared_ptr< RobotRaconteur::WrappedPipeSubscription > const &pipe_subscription) {
  void * jpipe_subscription = 0 ;
  
  if (!swig_callbackPipePacketReceived) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::WrappedPipeSubscriptionDirector::PipePacketReceived");
    return;
  } else {
    jpipe_subscription = pipe_subscription ? new boost::shared_ptr<  RobotRaconteur::WrappedPipeSubscription >(pipe_subscription) : 0; 
    swig_callbackPipePacketReceived(jpipe_subscription);
  }
}

SwigDirector_WrappedPipeSubscriptionDirector::~SwigDirector_WrappedPipeSubscriptionDirector() {
  
}


void SwigDirector_WrappedPipeSubscriptionDirector::swig_connect_director(SWIG_Callback0_t callbackPipePacketReceived) {
  swig_callbackPipePacketReceived = callbackPipePacketReceived;
}

void SwigDirector_WrappedPipeSubscriptionDirector::swig_init_callbacks() {
  swig_callbackPipePacketReceived = 0;
}

SwigDirector_UserLogRecordHandlerDirector::SwigDirector_UserLogRecordHandlerDirector() : RobotRaconteur::UserLogRecordHandlerDirector(), Swig::Director() {
  swig_init_callbacks();
}

void SwigDirector_UserLogRecordHandlerDirector::HandleLogRecord(RobotRaconteur::RRLogRecord const &record) {
  void * jrecord = 0 ;
  
  if (!swig_callbackHandleLogRecord) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::UserLogRecordHandlerDirector::HandleLogRecord");
    return;
  } else {
    jrecord = (RobotRaconteur::RRLogRecord *) &record; 
    swig_callbackHandleLogRecord(jrecord);
  }
}

SwigDirector_UserLogRecordHandlerDirector::~SwigDirector_UserLogRecordHandlerDirector() {
  
}


void SwigDirector_UserLogRecordHandlerDirector::swig_connect_director(SWIG_Callback0_t callbackHandleLogRecord) {
  swig_callbackHandleLogRecord = callbackHandleLogRecord;
}

void SwigDirector_UserLogRecordHandlerDirector::swig_init_callbacks() {
  swig_callbackHandleLogRecord = 0;
}

SwigDirector_ClientServiceListenerDirector::SwigDirector_ClientServiceListenerDirector() : ClientServiceListenerDirector(), Swig::Director() {
  swig_init_callbacks();
}

void SwigDirector_ClientServiceListenerDirector::Callback(int32_t code) {
  int jcode  ;
  
  if (!swig_callbackCallback) {
    ClientServiceListenerDirector::Callback(code);
    return;
  } else {
    jcode = code;
    swig_callbackCallback(jcode);
  }
}

void SwigDirector_ClientServiceListenerDirector::Callback2(int32_t code, std::string const &p) {
  int jcode  ;
  char * jp = 0 ;
  
  if (!swig_callbackCallback2) {
    ClientServiceListenerDirector::Callback2(code,p);
    return;
  } else {
    jcode = code;
    jp = SWIG_csharp_string_callback((&p)->c_str()); 
    swig_callbackCallback2(jcode, jp);
  }
}

SwigDirector_ClientServiceListenerDirector::~SwigDirector_ClientServiceListenerDirector() {
  
}


void SwigDirector_ClientServiceListenerDirector::swig_connect_director(SWIG_Callback0_t callbackCallback, SWIG_Callback1_t callbackCallback2) {
  swig_callbackCallback = callbackCallback;
  swig_callbackCallback2 = callbackCallback2;
}

void SwigDirector_ClientServiceListenerDirector::swig_init_callbacks() {
  swig_callbackCallback = 0;
  swig_callbackCallback2 = 0;
}

SwigDirector_RRNativeObjectHeapSupport::SwigDirector_RRNativeObjectHeapSupport() : RobotRaconteur::RRNativeObjectHeapSupport(), Swig::Director() {
  swig_init_callbacks();
}

void SwigDirector_RRNativeObjectHeapSupport::DeleteObject_i(int32_t id) {
  int jid  ;
  
  if (!swig_callbackDeleteObject_i) {
    Swig::DirectorPureVirtualException::raise("RobotRaconteur::RRNativeObjectHeapSupport::DeleteObject_i");
    return;
  } else {
    jid = id;
    swig_callbackDeleteObject_i(jid);
  }
}

SwigDirector_RRNativeObjectHeapSupport::~SwigDirector_RRNativeObjectHeapSupport() {
  
}


void SwigDirector_RRNativeObjectHeapSupport::swig_connect_director(SWIG_Callback0_t callbackDeleteObject_i) {
  swig_callbackDeleteObject_i = callbackDeleteObject_i;
}

void SwigDirector_RRNativeObjectHeapSupport::swig_init_callbacks() {
  swig_callbackDeleteObject_i = 0;
}


#ifdef __cplusplus
extern "C" {
#endif

SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_MessageFlags_ROUTING_INFO_get() {
  unsigned char jresult ;
  uint8_t result;
  
  result = (uint8_t)(uint8_t)RobotRaconteur::MessageFlags_ROUTING_INFO;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_MessageFlags_ENDPOINT_INFO_get() {
  unsigned char jresult ;
  uint8_t result;
  
  result = (uint8_t)(uint8_t)RobotRaconteur::MessageFlags_ENDPOINT_INFO;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_MessageFlags_PRIORITY_get() {
  unsigned char jresult ;
  uint8_t result;
  
  result = (uint8_t)(uint8_t)RobotRaconteur::MessageFlags_PRIORITY;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_MessageFlags_UNRELIABLE_get() {
  unsigned char jresult ;
  uint8_t result;
  
  result = (uint8_t)(uint8_t)RobotRaconteur::MessageFlags_UNRELIABLE;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_MessageFlags_META_INFO_get() {
  unsigned char jresult ;
  uint8_t result;
  
  result = (uint8_t)(uint8_t)RobotRaconteur::MessageFlags_META_INFO;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_MessageFlags_STRING_TABLE_get() {
  unsigned char jresult ;
  uint8_t result;
  
  result = (uint8_t)(uint8_t)RobotRaconteur::MessageFlags_STRING_TABLE;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_MessageFlags_MULTIPLE_ENTRIES_get() {
  unsigned char jresult ;
  uint8_t result;
  
  result = (uint8_t)(uint8_t)RobotRaconteur::MessageFlags_MULTIPLE_ENTRIES;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_MessageFlags_EXTENDED_get() {
  unsigned char jresult ;
  uint8_t result;
  
  result = (uint8_t)(uint8_t)RobotRaconteur::MessageFlags_EXTENDED;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_MessageFlags_Version2Compat_get() {
  unsigned char jresult ;
  uint8_t result;
  
  result = (uint8_t)(uint8_t)RobotRaconteur::MessageFlags_Version2Compat;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_MessageEntryFlags_SERVICE_PATH_STR_get() {
  unsigned char jresult ;
  uint8_t result;
  
  result = (uint8_t)(uint8_t)RobotRaconteur::MessageEntryFlags_SERVICE_PATH_STR;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_MessageEntryFlags_SERVICE_PATH_CODE_get() {
  unsigned char jresult ;
  uint8_t result;
  
  result = (uint8_t)(uint8_t)RobotRaconteur::MessageEntryFlags_SERVICE_PATH_CODE;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_MessageEntryFlags_MEMBER_NAME_STR_get() {
  unsigned char jresult ;
  uint8_t result;
  
  result = (uint8_t)(uint8_t)RobotRaconteur::MessageEntryFlags_MEMBER_NAME_STR;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_MessageEntryFlags_MEMBER_NAME_CODE_get() {
  unsigned char jresult ;
  uint8_t result;
  
  result = (uint8_t)(uint8_t)RobotRaconteur::MessageEntryFlags_MEMBER_NAME_CODE;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_MessageEntryFlags_REQUEST_ID_get() {
  unsigned char jresult ;
  uint8_t result;
  
  result = (uint8_t)(uint8_t)RobotRaconteur::MessageEntryFlags_REQUEST_ID;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_MessageEntryFlags_ERROR_get() {
  unsigned char jresult ;
  uint8_t result;
  
  result = (uint8_t)(uint8_t)RobotRaconteur::MessageEntryFlags_ERROR;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_MessageEntryFlags_META_INFO_get() {
  unsigned char jresult ;
  uint8_t result;
  
  result = (uint8_t)(uint8_t)RobotRaconteur::MessageEntryFlags_META_INFO;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_MessageEntryFlags_EXTENDED_get() {
  unsigned char jresult ;
  uint8_t result;
  
  result = (uint8_t)(uint8_t)RobotRaconteur::MessageEntryFlags_EXTENDED;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_MessageEntryFlags_Version2Compat_get() {
  unsigned char jresult ;
  uint8_t result;
  
  result = (uint8_t)(uint8_t)RobotRaconteur::MessageEntryFlags_Version2Compat;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_MessageElementFlags_ELEMENT_NAME_STR_get() {
  unsigned char jresult ;
  uint8_t result;
  
  result = (uint8_t)(uint8_t)RobotRaconteur::MessageElementFlags_ELEMENT_NAME_STR;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_MessageElementFlags_ELEMENT_NAME_CODE_get() {
  unsigned char jresult ;
  uint8_t result;
  
  result = (uint8_t)(uint8_t)RobotRaconteur::MessageElementFlags_ELEMENT_NAME_CODE;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_MessageElementFlags_ELEMENT_NUMBER_get() {
  unsigned char jresult ;
  uint8_t result;
  
  result = (uint8_t)(uint8_t)RobotRaconteur::MessageElementFlags_ELEMENT_NUMBER;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_MessageElementFlags_ELEMENT_TYPE_NAME_STR_get() {
  unsigned char jresult ;
  uint8_t result;
  
  result = (uint8_t)(uint8_t)RobotRaconteur::MessageElementFlags_ELEMENT_TYPE_NAME_STR;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_MessageElementFlags_ELEMENT_TYPE_NAME_CODE_get() {
  unsigned char jresult ;
  uint8_t result;
  
  result = (uint8_t)(uint8_t)RobotRaconteur::MessageElementFlags_ELEMENT_TYPE_NAME_CODE;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_MessageElementFlags_META_INFO_get() {
  unsigned char jresult ;
  uint8_t result;
  
  result = (uint8_t)(uint8_t)RobotRaconteur::MessageElementFlags_META_INFO;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_MessageElementFlags_EXTENDED_get() {
  unsigned char jresult ;
  uint8_t result;
  
  result = (uint8_t)(uint8_t)RobotRaconteur::MessageElementFlags_EXTENDED;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_MessageElementFlags_Version2Compat_get() {
  unsigned char jresult ;
  uint8_t result;
  
  result = (uint8_t)(uint8_t)RobotRaconteur::MessageElementFlags_Version2Compat;
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_RR_TIMEOUT_INFINITE_get() {
  int jresult ;
  int result;
  
  result = (int)((-1));
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_RR_VALUE_LIFESPAN_INFINITE_get() {
  int jresult ;
  int result;
  
  result = (int)((-1));
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TranspartCapabilityCode_PAGE_MASK_get() {
  unsigned int jresult ;
  uint32_t result;
  
  result = (uint32_t)(uint32_t)RobotRaconteur::TranspartCapabilityCode_PAGE_MASK;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TransportCapabilityCode_MESSAGE2_BASIC_PAGE_get() {
  unsigned int jresult ;
  uint32_t result;
  
  result = (uint32_t)(uint32_t)RobotRaconteur::TransportCapabilityCode_MESSAGE2_BASIC_PAGE;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TransportCapabilityCode_MESSAGE2_BASIC_ENABLE_get() {
  unsigned int jresult ;
  uint32_t result;
  
  result = (uint32_t)(uint32_t)RobotRaconteur::TransportCapabilityCode_MESSAGE2_BASIC_ENABLE;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TransportCapabilityCode_MESSAGE2_BASIC_CONNECTCOMBINED_get() {
  unsigned int jresult ;
  uint32_t result;
  
  result = (uint32_t)(uint32_t)RobotRaconteur::TransportCapabilityCode_MESSAGE2_BASIC_CONNECTCOMBINED;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TransportCapabilityCode_MESSAGE4_BASIC_PAGE_get() {
  unsigned int jresult ;
  uint32_t result;
  
  result = (uint32_t)(uint32_t)RobotRaconteur::TransportCapabilityCode_MESSAGE4_BASIC_PAGE;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TransportCapabilityCode_MESSAGE4_BASIC_ENABLE_get() {
  unsigned int jresult ;
  uint32_t result;
  
  result = (uint32_t)(uint32_t)RobotRaconteur::TransportCapabilityCode_MESSAGE4_BASIC_ENABLE;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TransportCapabilityCode_MESSAGE4_BASIC_CONNECTCOMBINED_get() {
  unsigned int jresult ;
  uint32_t result;
  
  result = (uint32_t)(uint32_t)RobotRaconteur::TransportCapabilityCode_MESSAGE4_BASIC_CONNECTCOMBINED;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TransportCapabilityCode_MESSAGE4_STRINGTABLE_PAGE_get() {
  unsigned int jresult ;
  uint32_t result;
  
  result = (uint32_t)(uint32_t)RobotRaconteur::TransportCapabilityCode_MESSAGE4_STRINGTABLE_PAGE;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TransportCapabilityCode_MESSAGE4_STRINGTABLE_ENABLE_get() {
  unsigned int jresult ;
  uint32_t result;
  
  result = (uint32_t)(uint32_t)RobotRaconteur::TransportCapabilityCode_MESSAGE4_STRINGTABLE_ENABLE;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TransportCapabilityCode_MESSAGE4_STRINGTABLE_MESSAGE_LOCAL_get() {
  unsigned int jresult ;
  uint32_t result;
  
  result = (uint32_t)(uint32_t)RobotRaconteur::TransportCapabilityCode_MESSAGE4_STRINGTABLE_MESSAGE_LOCAL;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TransportCapabilityCode_MESSAGE4_STRINGTABLE_STANDARD_TABLE_get() {
  unsigned int jresult ;
  uint32_t result;
  
  result = (uint32_t)(uint32_t)RobotRaconteur::TransportCapabilityCode_MESSAGE4_STRINGTABLE_STANDARD_TABLE;
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_FilesystemPath(char * jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  boost::filesystem::path *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  result = (boost::filesystem::path *)new boost::filesystem::path((std::string const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_FilesystemPath_string_(void * jarg1) {
  char * jresult ;
  boost::filesystem::path *arg1 = (boost::filesystem::path *) 0 ;
  std::string result;
  
  arg1 = (boost::filesystem::path *)jarg1; 
  result = (arg1)->string();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_FilesystemPath(void * jarg1) {
  boost::filesystem::path *arg1 = (boost::filesystem::path *) 0 ;
  
  arg1 = (boost::filesystem::path *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurExceptionHelper_SetRobotRaconteurException(void * jarg1, void * jarg2) {
  RobotRaconteurExceptionHelper *arg1 = (RobotRaconteurExceptionHelper *) 0 ;
  RobotRaconteur::HandlerErrorInfo *arg2 = 0 ;
  
  arg1 = (RobotRaconteurExceptionHelper *)jarg1; 
  arg2 = (RobotRaconteur::HandlerErrorInfo *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::HandlerErrorInfo const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->SetRobotRaconteurException((RobotRaconteur::HandlerErrorInfo const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurExceptionHelper_SetRobotRaconteurExceptionSwigExplicitRobotRaconteurExceptionHelper(void * jarg1, void * jarg2) {
  RobotRaconteurExceptionHelper *arg1 = (RobotRaconteurExceptionHelper *) 0 ;
  RobotRaconteur::HandlerErrorInfo *arg2 = 0 ;
  
  arg1 = (RobotRaconteurExceptionHelper *)jarg1; 
  arg2 = (RobotRaconteur::HandlerErrorInfo *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::HandlerErrorInfo const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->RobotRaconteurExceptionHelper::SetRobotRaconteurException((RobotRaconteur::HandlerErrorInfo const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_RobotRaconteurExceptionHelper(void * jarg1) {
  RobotRaconteurExceptionHelper *arg1 = (RobotRaconteurExceptionHelper *) 0 ;
  
  arg1 = (RobotRaconteurExceptionHelper *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_RobotRaconteurExceptionHelper() {
  void * jresult ;
  RobotRaconteurExceptionHelper *result = 0 ;
  
  
  try {
    result = (RobotRaconteurExceptionHelper *)new SwigDirector_RobotRaconteurExceptionHelper();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurExceptionHelper_director_connect(void *objarg, SwigDirector_RobotRaconteurExceptionHelper::SWIG_Callback0_t callback0) {
  RobotRaconteurExceptionHelper *obj = (RobotRaconteurExceptionHelper *)objarg;
  SwigDirector_RobotRaconteurExceptionHelper *director = static_cast<SwigDirector_RobotRaconteurExceptionHelper *>(obj);
  director->swig_connect_director(callback0);
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_robotRaconteurExceptionHelper_set(void * jarg1) {
  RobotRaconteurExceptionHelper *arg1 = (RobotRaconteurExceptionHelper *) 0 ;
  
  arg1 = (RobotRaconteurExceptionHelper *)jarg1; 
  robotRaconteurExceptionHelper = arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_robotRaconteurExceptionHelper_get() {
  void * jresult ;
  RobotRaconteurExceptionHelper *result = 0 ;
  
  result = (RobotRaconteurExceptionHelper *)robotRaconteurExceptionHelper;
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RRDirectorExceptionHelper_Reset() {
  try {
    RobotRaconteur::RRDirectorExceptionHelper::Reset();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RRDirectorExceptionHelper_SetError(void * jarg1, char * jarg2) {
  boost::intrusive_ptr< RobotRaconteur::MessageEntry > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageEntry > tempnull1 ;
  boost::intrusive_ptr< RobotRaconteur::MessageEntry > temp1 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg1 ;
  
  
  // intrusive_ptr by reference
  if ( jarg1 ) {
    smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry >**)&jarg1;
    temp1 = boost::intrusive_ptr<  RobotRaconteur::MessageEntry >(smartarg1->get(), true);
    arg1 = &temp1;
  } else {
    arg1 = &tempnull1;
  }
  
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    RobotRaconteur::RRDirectorExceptionHelper::SetError((boost::intrusive_ptr< RobotRaconteur::MessageEntry > const &)*arg1,(std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_RRDirectorExceptionHelper_IsErrorPending() {
  unsigned int jresult ;
  bool result;
  
  
  try {
    result = (bool)RobotRaconteur::RRDirectorExceptionHelper::IsErrorPending();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RRDirectorExceptionHelper_GetError() {
  void * jresult ;
  boost::intrusive_ptr< RobotRaconteur::MessageEntry > result;
  
  
  try {
    result = RobotRaconteur::RRDirectorExceptionHelper::GetError();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageEntry >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageEntry >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_RRDirectorExceptionHelper() {
  void * jresult ;
  RobotRaconteur::RRDirectorExceptionHelper *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::RRDirectorExceptionHelper *)new RobotRaconteur::RRDirectorExceptionHelper();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_RRDirectorExceptionHelper(void * jarg1) {
  RobotRaconteur::RRDirectorExceptionHelper *arg1 = (RobotRaconteur::RRDirectorExceptionHelper *) 0 ;
  
  arg1 = (RobotRaconteur::RRDirectorExceptionHelper *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorstring_Clear(void * jarg1) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  
  try {
    (arg1)->clear();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorstring_Add(void * jarg1, char * jarg2) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->push_back((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectorstring_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type result;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  
  try {
    result = ((std::vector< std::string > const *)arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectorstring_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type result;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  
  try {
    result = ((std::vector< std::string > const *)arg1)->capacity();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorstring_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type arg2 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (std::vector< std::string >::size_type)jarg2; 
  
  try {
    (arg1)->reserve(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorstring__SWIG_0() {
  void * jresult ;
  std::vector< std::string > *result = 0 ;
  
  
  try {
    result = (std::vector< std::string > *)new std::vector< std::string >();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorstring__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< std::string > *arg1 = 0 ;
  std::vector< std::string > *result = 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (std::vector< std::string > *)new std::vector< std::string >((std::vector< std::string > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorstring__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< std::string > *result = 0 ;
  
  arg1 = (int)jarg1; 
  
  try {
    try {
      result = (std::vector< std::string > *)new_std_vector_Sl_std_string_Sg___SWIG_2(arg1);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_vectorstring_getitemcopy(void * jarg1, int jarg2) {
  char * jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  std::string result;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = std_vector_Sl_std_string_Sg__getitemcopy(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_vectorstring_getitem(void * jarg1, int jarg2) {
  char * jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  std::vector< std::string >::value_type *result = 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< std::string >::value_type *) &std_vector_Sl_std_string_Sg__getitem(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorstring_setitem(void * jarg1, int jarg2, char * jarg3) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  std::string *arg3 = 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  try {
    try {
      std_vector_Sl_std_string_Sg__setitem(arg1,arg2,(std::string const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorstring_AddRange(void * jarg1, void * jarg2) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (std::vector< std::string > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return ;
  } 
  
  try {
    std_vector_Sl_std_string_Sg__AddRange(arg1,(std::vector< std::string > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorstring_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< std::string > *result = 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      result = (std::vector< std::string > *)std_vector_Sl_std_string_Sg__GetRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorstring_Insert(void * jarg1, int jarg2, char * jarg3) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  std::string *arg3 = 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  try {
    try {
      std_vector_Sl_std_string_Sg__Insert(arg1,arg2,(std::string const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorstring_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  std::vector< std::string > *arg3 = 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::string > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_std_string_Sg__InsertRange(arg1,arg2,(std::vector< std::string > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorstring_RemoveAt(void * jarg1, int jarg2) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      std_vector_Sl_std_string_Sg__RemoveAt(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorstring_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_std_string_Sg__RemoveRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorstring_Repeat(char * jarg1, int jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  int arg2 ;
  std::vector< std::string > *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< std::string > *)std_vector_Sl_std_string_Sg__Repeat((std::string const &)*arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorstring_Reverse__SWIG_0(void * jarg1) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  
  try {
    std_vector_Sl_std_string_Sg__Reverse__SWIG_0(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorstring_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_std_string_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorstring_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  std::vector< std::string > *arg3 = 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::string > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_std_string_Sg__SetRange(arg1,arg2,(std::vector< std::string > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_vectorstring_Contains(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::string *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (bool)std_vector_Sl_std_string_Sg__Contains(arg1,(std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_vectorstring_IndexOf(void * jarg1, char * jarg2) {
  int jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::string *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (int)std_vector_Sl_std_string_Sg__IndexOf(arg1,(std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_vectorstring_LastIndexOf(void * jarg1, char * jarg2) {
  int jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::string *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (int)std_vector_Sl_std_string_Sg__LastIndexOf(arg1,(std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_vectorstring_Remove(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::string *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (bool)std_vector_Sl_std_string_Sg__Remove(arg1,(std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_vectorstring(void * jarg1) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorint32_Clear(void * jarg1) {
  std::vector< int32_t > *arg1 = (std::vector< int32_t > *) 0 ;
  
  arg1 = (std::vector< int32_t > *)jarg1; 
  
  try {
    (arg1)->clear();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorint32_Add(void * jarg1, int jarg2) {
  std::vector< int32_t > *arg1 = (std::vector< int32_t > *) 0 ;
  int *arg2 = 0 ;
  int temp2 ;
  
  arg1 = (std::vector< int32_t > *)jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  
  try {
    (arg1)->push_back((int const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectorint32_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< int32_t > *arg1 = (std::vector< int32_t > *) 0 ;
  std::vector< int >::size_type result;
  
  arg1 = (std::vector< int32_t > *)jarg1; 
  
  try {
    result = ((std::vector< int32_t > const *)arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectorint32_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< int32_t > *arg1 = (std::vector< int32_t > *) 0 ;
  std::vector< int >::size_type result;
  
  arg1 = (std::vector< int32_t > *)jarg1; 
  
  try {
    result = ((std::vector< int32_t > const *)arg1)->capacity();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorint32_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< int32_t > *arg1 = (std::vector< int32_t > *) 0 ;
  std::vector< int >::size_type arg2 ;
  
  arg1 = (std::vector< int32_t > *)jarg1; 
  arg2 = (std::vector< int >::size_type)jarg2; 
  
  try {
    (arg1)->reserve(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorint32__SWIG_0() {
  void * jresult ;
  std::vector< int32_t > *result = 0 ;
  
  
  try {
    result = (std::vector< int32_t > *)new std::vector< int32_t >();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorint32__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< int32_t > *arg1 = 0 ;
  std::vector< int32_t > *result = 0 ;
  
  arg1 = (std::vector< int32_t > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int32_t > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (std::vector< int32_t > *)new std::vector< int32_t >((std::vector< int32_t > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorint32__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< int32_t > *result = 0 ;
  
  arg1 = (int)jarg1; 
  
  try {
    try {
      result = (std::vector< int32_t > *)new_std_vector_Sl_int32_t_Sg___SWIG_2(arg1);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_vectorint32_getitemcopy(void * jarg1, int jarg2) {
  int jresult ;
  std::vector< int32_t > *arg1 = (std::vector< int32_t > *) 0 ;
  int arg2 ;
  int result;
  
  arg1 = (std::vector< int32_t > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (int)std_vector_Sl_int32_t_Sg__getitemcopy(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_vectorint32_getitem(void * jarg1, int jarg2) {
  int jresult ;
  std::vector< int32_t > *arg1 = (std::vector< int32_t > *) 0 ;
  int arg2 ;
  std::vector< int >::value_type *result = 0 ;
  
  arg1 = (std::vector< int32_t > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< int >::value_type *) &std_vector_Sl_int32_t_Sg__getitem(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = *result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorint32_setitem(void * jarg1, int jarg2, int jarg3) {
  std::vector< int32_t > *arg1 = (std::vector< int32_t > *) 0 ;
  int arg2 ;
  int *arg3 = 0 ;
  int temp3 ;
  
  arg1 = (std::vector< int32_t > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (int)jarg3; 
  arg3 = &temp3; 
  
  try {
    try {
      std_vector_Sl_int32_t_Sg__setitem(arg1,arg2,(int const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorint32_AddRange(void * jarg1, void * jarg2) {
  std::vector< int32_t > *arg1 = (std::vector< int32_t > *) 0 ;
  std::vector< int > *arg2 = 0 ;
  
  arg1 = (std::vector< int32_t > *)jarg1; 
  arg2 = (std::vector< int > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return ;
  } 
  
  try {
    std_vector_Sl_int32_t_Sg__AddRange(arg1,(std::vector< int > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorint32_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< int32_t > *arg1 = (std::vector< int32_t > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (std::vector< int32_t > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      result = (std::vector< int > *)std_vector_Sl_int32_t_Sg__GetRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorint32_Insert(void * jarg1, int jarg2, int jarg3) {
  std::vector< int32_t > *arg1 = (std::vector< int32_t > *) 0 ;
  int arg2 ;
  int *arg3 = 0 ;
  int temp3 ;
  
  arg1 = (std::vector< int32_t > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (int)jarg3; 
  arg3 = &temp3; 
  
  try {
    try {
      std_vector_Sl_int32_t_Sg__Insert(arg1,arg2,(int const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorint32_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< int32_t > *arg1 = (std::vector< int32_t > *) 0 ;
  int arg2 ;
  std::vector< int > *arg3 = 0 ;
  
  arg1 = (std::vector< int32_t > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< int > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_int32_t_Sg__InsertRange(arg1,arg2,(std::vector< int > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorint32_RemoveAt(void * jarg1, int jarg2) {
  std::vector< int32_t > *arg1 = (std::vector< int32_t > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< int32_t > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      std_vector_Sl_int32_t_Sg__RemoveAt(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorint32_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< int32_t > *arg1 = (std::vector< int32_t > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< int32_t > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_int32_t_Sg__RemoveRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorint32_Repeat(int jarg1, int jarg2) {
  void * jresult ;
  int *arg1 = 0 ;
  int arg2 ;
  int temp1 ;
  std::vector< int > *result = 0 ;
  
  temp1 = (int)jarg1; 
  arg1 = &temp1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< int > *)std_vector_Sl_int32_t_Sg__Repeat((int const &)*arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorint32_Reverse__SWIG_0(void * jarg1) {
  std::vector< int32_t > *arg1 = (std::vector< int32_t > *) 0 ;
  
  arg1 = (std::vector< int32_t > *)jarg1; 
  
  try {
    std_vector_Sl_int32_t_Sg__Reverse__SWIG_0(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorint32_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< int32_t > *arg1 = (std::vector< int32_t > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< int32_t > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_int32_t_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorint32_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< int32_t > *arg1 = (std::vector< int32_t > *) 0 ;
  int arg2 ;
  std::vector< int > *arg3 = 0 ;
  
  arg1 = (std::vector< int32_t > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< int > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_int32_t_Sg__SetRange(arg1,arg2,(std::vector< int > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_vectorint32_Contains(void * jarg1, int jarg2) {
  unsigned int jresult ;
  std::vector< int32_t > *arg1 = (std::vector< int32_t > *) 0 ;
  int *arg2 = 0 ;
  int temp2 ;
  bool result;
  
  arg1 = (std::vector< int32_t > *)jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  
  try {
    result = (bool)std_vector_Sl_int32_t_Sg__Contains(arg1,(int const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_vectorint32_IndexOf(void * jarg1, int jarg2) {
  int jresult ;
  std::vector< int32_t > *arg1 = (std::vector< int32_t > *) 0 ;
  int *arg2 = 0 ;
  int temp2 ;
  int result;
  
  arg1 = (std::vector< int32_t > *)jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  
  try {
    result = (int)std_vector_Sl_int32_t_Sg__IndexOf(arg1,(int const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_vectorint32_LastIndexOf(void * jarg1, int jarg2) {
  int jresult ;
  std::vector< int32_t > *arg1 = (std::vector< int32_t > *) 0 ;
  int *arg2 = 0 ;
  int temp2 ;
  int result;
  
  arg1 = (std::vector< int32_t > *)jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  
  try {
    result = (int)std_vector_Sl_int32_t_Sg__LastIndexOf(arg1,(int const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_vectorint32_Remove(void * jarg1, int jarg2) {
  unsigned int jresult ;
  std::vector< int32_t > *arg1 = (std::vector< int32_t > *) 0 ;
  int *arg2 = 0 ;
  int temp2 ;
  bool result;
  
  arg1 = (std::vector< int32_t > *)jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  
  try {
    result = (bool)std_vector_Sl_int32_t_Sg__Remove(arg1,(int const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_vectorint32(void * jarg1) {
  std::vector< int32_t > *arg1 = (std::vector< int32_t > *) 0 ;
  
  arg1 = (std::vector< int32_t > *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectoruint32_Clear(void * jarg1) {
  std::vector< uint32_t > *arg1 = (std::vector< uint32_t > *) 0 ;
  
  arg1 = (std::vector< uint32_t > *)jarg1; 
  
  try {
    (arg1)->clear();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectoruint32_Add(void * jarg1, unsigned int jarg2) {
  std::vector< uint32_t > *arg1 = (std::vector< uint32_t > *) 0 ;
  unsigned int *arg2 = 0 ;
  unsigned int temp2 ;
  
  arg1 = (std::vector< uint32_t > *)jarg1; 
  temp2 = (unsigned int)jarg2; 
  arg2 = &temp2; 
  
  try {
    (arg1)->push_back((unsigned int const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectoruint32_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< uint32_t > *arg1 = (std::vector< uint32_t > *) 0 ;
  std::vector< unsigned int >::size_type result;
  
  arg1 = (std::vector< uint32_t > *)jarg1; 
  
  try {
    result = ((std::vector< uint32_t > const *)arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectoruint32_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< uint32_t > *arg1 = (std::vector< uint32_t > *) 0 ;
  std::vector< unsigned int >::size_type result;
  
  arg1 = (std::vector< uint32_t > *)jarg1; 
  
  try {
    result = ((std::vector< uint32_t > const *)arg1)->capacity();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectoruint32_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< uint32_t > *arg1 = (std::vector< uint32_t > *) 0 ;
  std::vector< unsigned int >::size_type arg2 ;
  
  arg1 = (std::vector< uint32_t > *)jarg1; 
  arg2 = (std::vector< unsigned int >::size_type)jarg2; 
  
  try {
    (arg1)->reserve(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectoruint32__SWIG_0() {
  void * jresult ;
  std::vector< uint32_t > *result = 0 ;
  
  
  try {
    result = (std::vector< uint32_t > *)new std::vector< uint32_t >();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectoruint32__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< uint32_t > *arg1 = 0 ;
  std::vector< uint32_t > *result = 0 ;
  
  arg1 = (std::vector< uint32_t > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint32_t > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (std::vector< uint32_t > *)new std::vector< uint32_t >((std::vector< uint32_t > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectoruint32__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< uint32_t > *result = 0 ;
  
  arg1 = (int)jarg1; 
  
  try {
    try {
      result = (std::vector< uint32_t > *)new_std_vector_Sl_uint32_t_Sg___SWIG_2(arg1);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_vectoruint32_getitemcopy(void * jarg1, int jarg2) {
  unsigned int jresult ;
  std::vector< uint32_t > *arg1 = (std::vector< uint32_t > *) 0 ;
  int arg2 ;
  unsigned int result;
  
  arg1 = (std::vector< uint32_t > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (unsigned int)std_vector_Sl_uint32_t_Sg__getitemcopy(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_vectoruint32_getitem(void * jarg1, int jarg2) {
  unsigned int jresult ;
  std::vector< uint32_t > *arg1 = (std::vector< uint32_t > *) 0 ;
  int arg2 ;
  std::vector< unsigned int >::value_type *result = 0 ;
  
  arg1 = (std::vector< uint32_t > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< unsigned int >::value_type *) &std_vector_Sl_uint32_t_Sg__getitem(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = *result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectoruint32_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
  std::vector< uint32_t > *arg1 = (std::vector< uint32_t > *) 0 ;
  int arg2 ;
  unsigned int *arg3 = 0 ;
  unsigned int temp3 ;
  
  arg1 = (std::vector< uint32_t > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (unsigned int)jarg3; 
  arg3 = &temp3; 
  
  try {
    try {
      std_vector_Sl_uint32_t_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectoruint32_AddRange(void * jarg1, void * jarg2) {
  std::vector< uint32_t > *arg1 = (std::vector< uint32_t > *) 0 ;
  std::vector< unsigned int > *arg2 = 0 ;
  
  arg1 = (std::vector< uint32_t > *)jarg1; 
  arg2 = (std::vector< unsigned int > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
    return ;
  } 
  
  try {
    std_vector_Sl_uint32_t_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectoruint32_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< uint32_t > *arg1 = (std::vector< uint32_t > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< unsigned int > *result = 0 ;
  
  arg1 = (std::vector< uint32_t > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      result = (std::vector< unsigned int > *)std_vector_Sl_uint32_t_Sg__GetRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectoruint32_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
  std::vector< uint32_t > *arg1 = (std::vector< uint32_t > *) 0 ;
  int arg2 ;
  unsigned int *arg3 = 0 ;
  unsigned int temp3 ;
  
  arg1 = (std::vector< uint32_t > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (unsigned int)jarg3; 
  arg3 = &temp3; 
  
  try {
    try {
      std_vector_Sl_uint32_t_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectoruint32_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< uint32_t > *arg1 = (std::vector< uint32_t > *) 0 ;
  int arg2 ;
  std::vector< unsigned int > *arg3 = 0 ;
  
  arg1 = (std::vector< uint32_t > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< unsigned int > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_uint32_t_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectoruint32_RemoveAt(void * jarg1, int jarg2) {
  std::vector< uint32_t > *arg1 = (std::vector< uint32_t > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< uint32_t > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      std_vector_Sl_uint32_t_Sg__RemoveAt(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectoruint32_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< uint32_t > *arg1 = (std::vector< uint32_t > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< uint32_t > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_uint32_t_Sg__RemoveRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectoruint32_Repeat(unsigned int jarg1, int jarg2) {
  void * jresult ;
  unsigned int *arg1 = 0 ;
  int arg2 ;
  unsigned int temp1 ;
  std::vector< unsigned int > *result = 0 ;
  
  temp1 = (unsigned int)jarg1; 
  arg1 = &temp1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< unsigned int > *)std_vector_Sl_uint32_t_Sg__Repeat((unsigned int const &)*arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectoruint32_Reverse__SWIG_0(void * jarg1) {
  std::vector< uint32_t > *arg1 = (std::vector< uint32_t > *) 0 ;
  
  arg1 = (std::vector< uint32_t > *)jarg1; 
  
  try {
    std_vector_Sl_uint32_t_Sg__Reverse__SWIG_0(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectoruint32_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< uint32_t > *arg1 = (std::vector< uint32_t > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< uint32_t > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_uint32_t_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectoruint32_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< uint32_t > *arg1 = (std::vector< uint32_t > *) 0 ;
  int arg2 ;
  std::vector< unsigned int > *arg3 = 0 ;
  
  arg1 = (std::vector< uint32_t > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< unsigned int > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_uint32_t_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_vectoruint32_Contains(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ;
  std::vector< uint32_t > *arg1 = (std::vector< uint32_t > *) 0 ;
  unsigned int *arg2 = 0 ;
  unsigned int temp2 ;
  bool result;
  
  arg1 = (std::vector< uint32_t > *)jarg1; 
  temp2 = (unsigned int)jarg2; 
  arg2 = &temp2; 
  
  try {
    result = (bool)std_vector_Sl_uint32_t_Sg__Contains(arg1,(unsigned int const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_vectoruint32_IndexOf(void * jarg1, unsigned int jarg2) {
  int jresult ;
  std::vector< uint32_t > *arg1 = (std::vector< uint32_t > *) 0 ;
  unsigned int *arg2 = 0 ;
  unsigned int temp2 ;
  int result;
  
  arg1 = (std::vector< uint32_t > *)jarg1; 
  temp2 = (unsigned int)jarg2; 
  arg2 = &temp2; 
  
  try {
    result = (int)std_vector_Sl_uint32_t_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_vectoruint32_LastIndexOf(void * jarg1, unsigned int jarg2) {
  int jresult ;
  std::vector< uint32_t > *arg1 = (std::vector< uint32_t > *) 0 ;
  unsigned int *arg2 = 0 ;
  unsigned int temp2 ;
  int result;
  
  arg1 = (std::vector< uint32_t > *)jarg1; 
  temp2 = (unsigned int)jarg2; 
  arg2 = &temp2; 
  
  try {
    result = (int)std_vector_Sl_uint32_t_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_vectoruint32_Remove(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ;
  std::vector< uint32_t > *arg1 = (std::vector< uint32_t > *) 0 ;
  unsigned int *arg2 = 0 ;
  unsigned int temp2 ;
  bool result;
  
  arg1 = (std::vector< uint32_t > *)jarg1; 
  temp2 = (unsigned int)jarg2; 
  arg2 = &temp2; 
  
  try {
    result = (bool)std_vector_Sl_uint32_t_Sg__Remove(arg1,(unsigned int const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_vectoruint32(void * jarg1) {
  std::vector< uint32_t > *arg1 = (std::vector< uint32_t > *) 0 ;
  
  arg1 = (std::vector< uint32_t > *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_int8_t_Clear(void * jarg1) {
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  
  arg1 = (std::vector< int8_t > *)jarg1; 
  
  try {
    (arg1)->clear();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_int8_t_Add(void * jarg1, signed char jarg2) {
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  signed char *arg2 = 0 ;
  signed char temp2 ;
  
  arg1 = (std::vector< int8_t > *)jarg1; 
  temp2 = (signed char)jarg2; 
  arg2 = &temp2; 
  
  try {
    (arg1)->push_back((signed char const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vector_int8_t_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  std::vector< signed char >::size_type result;
  
  arg1 = (std::vector< int8_t > *)jarg1; 
  
  try {
    result = ((std::vector< int8_t > const *)arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vector_int8_t_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  std::vector< signed char >::size_type result;
  
  arg1 = (std::vector< int8_t > *)jarg1; 
  
  try {
    result = ((std::vector< int8_t > const *)arg1)->capacity();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_int8_t_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  std::vector< signed char >::size_type arg2 ;
  
  arg1 = (std::vector< int8_t > *)jarg1; 
  arg2 = (std::vector< signed char >::size_type)jarg2; 
  
  try {
    (arg1)->reserve(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vector_int8_t__SWIG_0() {
  void * jresult ;
  std::vector< int8_t > *result = 0 ;
  
  
  try {
    result = (std::vector< int8_t > *)new std::vector< int8_t >();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vector_int8_t__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< int8_t > *arg1 = 0 ;
  std::vector< int8_t > *result = 0 ;
  
  arg1 = (std::vector< int8_t > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int8_t > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (std::vector< int8_t > *)new std::vector< int8_t >((std::vector< int8_t > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vector_int8_t__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< int8_t > *result = 0 ;
  
  arg1 = (int)jarg1; 
  
  try {
    try {
      result = (std::vector< int8_t > *)new_std_vector_Sl_int8_t_Sg___SWIG_2(arg1);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT signed char SWIGSTDCALL CSharp_RobotRaconteur_vector_int8_t_getitemcopy(void * jarg1, int jarg2) {
  signed char jresult ;
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  int arg2 ;
  signed char result;
  
  arg1 = (std::vector< int8_t > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (signed char)std_vector_Sl_int8_t_Sg__getitemcopy(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT signed char SWIGSTDCALL CSharp_RobotRaconteur_vector_int8_t_getitem(void * jarg1, int jarg2) {
  signed char jresult ;
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  int arg2 ;
  std::vector< signed char >::value_type *result = 0 ;
  
  arg1 = (std::vector< int8_t > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< signed char >::value_type *) &std_vector_Sl_int8_t_Sg__getitem(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = *result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_int8_t_setitem(void * jarg1, int jarg2, signed char jarg3) {
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  int arg2 ;
  signed char *arg3 = 0 ;
  signed char temp3 ;
  
  arg1 = (std::vector< int8_t > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (signed char)jarg3; 
  arg3 = &temp3; 
  
  try {
    try {
      std_vector_Sl_int8_t_Sg__setitem(arg1,arg2,(signed char const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_int8_t_AddRange(void * jarg1, void * jarg2) {
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  std::vector< signed char > *arg2 = 0 ;
  
  arg1 = (std::vector< int8_t > *)jarg1; 
  arg2 = (std::vector< signed char > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< signed char > const & type is null", 0);
    return ;
  } 
  
  try {
    std_vector_Sl_int8_t_Sg__AddRange(arg1,(std::vector< signed char > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vector_int8_t_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< signed char > *result = 0 ;
  
  arg1 = (std::vector< int8_t > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      result = (std::vector< signed char > *)std_vector_Sl_int8_t_Sg__GetRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_int8_t_Insert(void * jarg1, int jarg2, signed char jarg3) {
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  int arg2 ;
  signed char *arg3 = 0 ;
  signed char temp3 ;
  
  arg1 = (std::vector< int8_t > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (signed char)jarg3; 
  arg3 = &temp3; 
  
  try {
    try {
      std_vector_Sl_int8_t_Sg__Insert(arg1,arg2,(signed char const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_int8_t_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  int arg2 ;
  std::vector< signed char > *arg3 = 0 ;
  
  arg1 = (std::vector< int8_t > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< signed char > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< signed char > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_int8_t_Sg__InsertRange(arg1,arg2,(std::vector< signed char > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_int8_t_RemoveAt(void * jarg1, int jarg2) {
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< int8_t > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      std_vector_Sl_int8_t_Sg__RemoveAt(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_int8_t_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< int8_t > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_int8_t_Sg__RemoveRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vector_int8_t_Repeat(signed char jarg1, int jarg2) {
  void * jresult ;
  signed char *arg1 = 0 ;
  int arg2 ;
  signed char temp1 ;
  std::vector< signed char > *result = 0 ;
  
  temp1 = (signed char)jarg1; 
  arg1 = &temp1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< signed char > *)std_vector_Sl_int8_t_Sg__Repeat((signed char const &)*arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_int8_t_Reverse__SWIG_0(void * jarg1) {
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  
  arg1 = (std::vector< int8_t > *)jarg1; 
  
  try {
    std_vector_Sl_int8_t_Sg__Reverse__SWIG_0(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_int8_t_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< int8_t > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_int8_t_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_int8_t_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  int arg2 ;
  std::vector< signed char > *arg3 = 0 ;
  
  arg1 = (std::vector< int8_t > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< signed char > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< signed char > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_int8_t_Sg__SetRange(arg1,arg2,(std::vector< signed char > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_vector_int8_t_Contains(void * jarg1, signed char jarg2) {
  unsigned int jresult ;
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  signed char *arg2 = 0 ;
  signed char temp2 ;
  bool result;
  
  arg1 = (std::vector< int8_t > *)jarg1; 
  temp2 = (signed char)jarg2; 
  arg2 = &temp2; 
  
  try {
    result = (bool)std_vector_Sl_int8_t_Sg__Contains(arg1,(signed char const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_vector_int8_t_IndexOf(void * jarg1, signed char jarg2) {
  int jresult ;
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  signed char *arg2 = 0 ;
  signed char temp2 ;
  int result;
  
  arg1 = (std::vector< int8_t > *)jarg1; 
  temp2 = (signed char)jarg2; 
  arg2 = &temp2; 
  
  try {
    result = (int)std_vector_Sl_int8_t_Sg__IndexOf(arg1,(signed char const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_vector_int8_t_LastIndexOf(void * jarg1, signed char jarg2) {
  int jresult ;
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  signed char *arg2 = 0 ;
  signed char temp2 ;
  int result;
  
  arg1 = (std::vector< int8_t > *)jarg1; 
  temp2 = (signed char)jarg2; 
  arg2 = &temp2; 
  
  try {
    result = (int)std_vector_Sl_int8_t_Sg__LastIndexOf(arg1,(signed char const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_vector_int8_t_Remove(void * jarg1, signed char jarg2) {
  unsigned int jresult ;
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  signed char *arg2 = 0 ;
  signed char temp2 ;
  bool result;
  
  arg1 = (std::vector< int8_t > *)jarg1; 
  temp2 = (signed char)jarg2; 
  arg2 = &temp2; 
  
  try {
    result = (bool)std_vector_Sl_int8_t_Sg__Remove(arg1,(signed char const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_vector_int8_t(void * jarg1) {
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  
  arg1 = (std::vector< int8_t > *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_uint8_t_Clear(void * jarg1) {
  std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
  
  arg1 = (std::vector< uint8_t > *)jarg1; 
  
  try {
    (arg1)->clear();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_uint8_t_Add(void * jarg1, unsigned char jarg2) {
  std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
  unsigned char *arg2 = 0 ;
  unsigned char temp2 ;
  
  arg1 = (std::vector< uint8_t > *)jarg1; 
  temp2 = (unsigned char)jarg2; 
  arg2 = &temp2; 
  
  try {
    (arg1)->push_back((unsigned char const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vector_uint8_t_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
  std::vector< unsigned char >::size_type result;
  
  arg1 = (std::vector< uint8_t > *)jarg1; 
  
  try {
    result = ((std::vector< uint8_t > const *)arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vector_uint8_t_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
  std::vector< unsigned char >::size_type result;
  
  arg1 = (std::vector< uint8_t > *)jarg1; 
  
  try {
    result = ((std::vector< uint8_t > const *)arg1)->capacity();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_uint8_t_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
  std::vector< unsigned char >::size_type arg2 ;
  
  arg1 = (std::vector< uint8_t > *)jarg1; 
  arg2 = (std::vector< unsigned char >::size_type)jarg2; 
  
  try {
    (arg1)->reserve(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vector_uint8_t__SWIG_0() {
  void * jresult ;
  std::vector< uint8_t > *result = 0 ;
  
  
  try {
    result = (std::vector< uint8_t > *)new std::vector< uint8_t >();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vector_uint8_t__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< uint8_t > *arg1 = 0 ;
  std::vector< uint8_t > *result = 0 ;
  
  arg1 = (std::vector< uint8_t > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint8_t > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (std::vector< uint8_t > *)new std::vector< uint8_t >((std::vector< uint8_t > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vector_uint8_t__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< uint8_t > *result = 0 ;
  
  arg1 = (int)jarg1; 
  
  try {
    try {
      result = (std::vector< uint8_t > *)new_std_vector_Sl_uint8_t_Sg___SWIG_2(arg1);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_vector_uint8_t_getitemcopy(void * jarg1, int jarg2) {
  unsigned char jresult ;
  std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
  int arg2 ;
  unsigned char result;
  
  arg1 = (std::vector< uint8_t > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (unsigned char)std_vector_Sl_uint8_t_Sg__getitemcopy(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_vector_uint8_t_getitem(void * jarg1, int jarg2) {
  unsigned char jresult ;
  std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
  int arg2 ;
  std::vector< unsigned char >::value_type *result = 0 ;
  
  arg1 = (std::vector< uint8_t > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< unsigned char >::value_type *) &std_vector_Sl_uint8_t_Sg__getitem(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = *result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_uint8_t_setitem(void * jarg1, int jarg2, unsigned char jarg3) {
  std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
  int arg2 ;
  unsigned char *arg3 = 0 ;
  unsigned char temp3 ;
  
  arg1 = (std::vector< uint8_t > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (unsigned char)jarg3; 
  arg3 = &temp3; 
  
  try {
    try {
      std_vector_Sl_uint8_t_Sg__setitem(arg1,arg2,(unsigned char const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_uint8_t_AddRange(void * jarg1, void * jarg2) {
  std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
  std::vector< unsigned char > *arg2 = 0 ;
  
  arg1 = (std::vector< uint8_t > *)jarg1; 
  arg2 = (std::vector< unsigned char > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned char > const & type is null", 0);
    return ;
  } 
  
  try {
    std_vector_Sl_uint8_t_Sg__AddRange(arg1,(std::vector< unsigned char > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vector_uint8_t_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< unsigned char > *result = 0 ;
  
  arg1 = (std::vector< uint8_t > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      result = (std::vector< unsigned char > *)std_vector_Sl_uint8_t_Sg__GetRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_uint8_t_Insert(void * jarg1, int jarg2, unsigned char jarg3) {
  std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
  int arg2 ;
  unsigned char *arg3 = 0 ;
  unsigned char temp3 ;
  
  arg1 = (std::vector< uint8_t > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (unsigned char)jarg3; 
  arg3 = &temp3; 
  
  try {
    try {
      std_vector_Sl_uint8_t_Sg__Insert(arg1,arg2,(unsigned char const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_uint8_t_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
  int arg2 ;
  std::vector< unsigned char > *arg3 = 0 ;
  
  arg1 = (std::vector< uint8_t > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< unsigned char > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned char > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_uint8_t_Sg__InsertRange(arg1,arg2,(std::vector< unsigned char > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_uint8_t_RemoveAt(void * jarg1, int jarg2) {
  std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< uint8_t > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      std_vector_Sl_uint8_t_Sg__RemoveAt(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_uint8_t_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< uint8_t > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_uint8_t_Sg__RemoveRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vector_uint8_t_Repeat(unsigned char jarg1, int jarg2) {
  void * jresult ;
  unsigned char *arg1 = 0 ;
  int arg2 ;
  unsigned char temp1 ;
  std::vector< unsigned char > *result = 0 ;
  
  temp1 = (unsigned char)jarg1; 
  arg1 = &temp1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< unsigned char > *)std_vector_Sl_uint8_t_Sg__Repeat((unsigned char const &)*arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_uint8_t_Reverse__SWIG_0(void * jarg1) {
  std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
  
  arg1 = (std::vector< uint8_t > *)jarg1; 
  
  try {
    std_vector_Sl_uint8_t_Sg__Reverse__SWIG_0(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_uint8_t_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< uint8_t > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_uint8_t_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_uint8_t_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
  int arg2 ;
  std::vector< unsigned char > *arg3 = 0 ;
  
  arg1 = (std::vector< uint8_t > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< unsigned char > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned char > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_uint8_t_Sg__SetRange(arg1,arg2,(std::vector< unsigned char > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_vector_uint8_t_Contains(void * jarg1, unsigned char jarg2) {
  unsigned int jresult ;
  std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
  unsigned char *arg2 = 0 ;
  unsigned char temp2 ;
  bool result;
  
  arg1 = (std::vector< uint8_t > *)jarg1; 
  temp2 = (unsigned char)jarg2; 
  arg2 = &temp2; 
  
  try {
    result = (bool)std_vector_Sl_uint8_t_Sg__Contains(arg1,(unsigned char const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_vector_uint8_t_IndexOf(void * jarg1, unsigned char jarg2) {
  int jresult ;
  std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
  unsigned char *arg2 = 0 ;
  unsigned char temp2 ;
  int result;
  
  arg1 = (std::vector< uint8_t > *)jarg1; 
  temp2 = (unsigned char)jarg2; 
  arg2 = &temp2; 
  
  try {
    result = (int)std_vector_Sl_uint8_t_Sg__IndexOf(arg1,(unsigned char const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_vector_uint8_t_LastIndexOf(void * jarg1, unsigned char jarg2) {
  int jresult ;
  std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
  unsigned char *arg2 = 0 ;
  unsigned char temp2 ;
  int result;
  
  arg1 = (std::vector< uint8_t > *)jarg1; 
  temp2 = (unsigned char)jarg2; 
  arg2 = &temp2; 
  
  try {
    result = (int)std_vector_Sl_uint8_t_Sg__LastIndexOf(arg1,(unsigned char const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_vector_uint8_t_Remove(void * jarg1, unsigned char jarg2) {
  unsigned int jresult ;
  std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
  unsigned char *arg2 = 0 ;
  unsigned char temp2 ;
  bool result;
  
  arg1 = (std::vector< uint8_t > *)jarg1; 
  temp2 = (unsigned char)jarg2; 
  arg2 = &temp2; 
  
  try {
    result = (bool)std_vector_Sl_uint8_t_Sg__Remove(arg1,(unsigned char const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_vector_uint8_t(void * jarg1) {
  std::vector< uint8_t > *arg1 = (std::vector< uint8_t > *) 0 ;
  
  arg1 = (std::vector< uint8_t > *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_uint64_t_Clear(void * jarg1) {
  std::vector< uint64_t > *arg1 = (std::vector< uint64_t > *) 0 ;
  
  arg1 = (std::vector< uint64_t > *)jarg1; 
  
  try {
    (arg1)->clear();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_uint64_t_Add(void * jarg1, unsigned long long jarg2) {
  std::vector< uint64_t > *arg1 = (std::vector< uint64_t > *) 0 ;
  unsigned long long *arg2 = 0 ;
  unsigned long long temp2 ;
  
  arg1 = (std::vector< uint64_t > *)jarg1; 
  temp2 = (unsigned long long)jarg2; 
  arg2 = &temp2; 
  
  try {
    (arg1)->push_back((unsigned long long const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vector_uint64_t_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< uint64_t > *arg1 = (std::vector< uint64_t > *) 0 ;
  std::vector< unsigned long long >::size_type result;
  
  arg1 = (std::vector< uint64_t > *)jarg1; 
  
  try {
    result = ((std::vector< uint64_t > const *)arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vector_uint64_t_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< uint64_t > *arg1 = (std::vector< uint64_t > *) 0 ;
  std::vector< unsigned long long >::size_type result;
  
  arg1 = (std::vector< uint64_t > *)jarg1; 
  
  try {
    result = ((std::vector< uint64_t > const *)arg1)->capacity();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_uint64_t_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< uint64_t > *arg1 = (std::vector< uint64_t > *) 0 ;
  std::vector< unsigned long long >::size_type arg2 ;
  
  arg1 = (std::vector< uint64_t > *)jarg1; 
  arg2 = (std::vector< unsigned long long >::size_type)jarg2; 
  
  try {
    (arg1)->reserve(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vector_uint64_t__SWIG_0() {
  void * jresult ;
  std::vector< uint64_t > *result = 0 ;
  
  
  try {
    result = (std::vector< uint64_t > *)new std::vector< uint64_t >();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vector_uint64_t__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< uint64_t > *arg1 = 0 ;
  std::vector< uint64_t > *result = 0 ;
  
  arg1 = (std::vector< uint64_t > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (std::vector< uint64_t > *)new std::vector< uint64_t >((std::vector< uint64_t > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vector_uint64_t__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< uint64_t > *result = 0 ;
  
  arg1 = (int)jarg1; 
  
  try {
    try {
      result = (std::vector< uint64_t > *)new_std_vector_Sl_uint64_t_Sg___SWIG_2(arg1);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long long SWIGSTDCALL CSharp_RobotRaconteur_vector_uint64_t_getitemcopy(void * jarg1, int jarg2) {
  unsigned long long jresult ;
  std::vector< uint64_t > *arg1 = (std::vector< uint64_t > *) 0 ;
  int arg2 ;
  unsigned long long result;
  
  arg1 = (std::vector< uint64_t > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (unsigned long long)std_vector_Sl_uint64_t_Sg__getitemcopy(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned long long SWIGSTDCALL CSharp_RobotRaconteur_vector_uint64_t_getitem(void * jarg1, int jarg2) {
  unsigned long long jresult ;
  std::vector< uint64_t > *arg1 = (std::vector< uint64_t > *) 0 ;
  int arg2 ;
  std::vector< unsigned long long >::value_type *result = 0 ;
  
  arg1 = (std::vector< uint64_t > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< unsigned long long >::value_type *) &std_vector_Sl_uint64_t_Sg__getitem(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = *result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_uint64_t_setitem(void * jarg1, int jarg2, unsigned long long jarg3) {
  std::vector< uint64_t > *arg1 = (std::vector< uint64_t > *) 0 ;
  int arg2 ;
  unsigned long long *arg3 = 0 ;
  unsigned long long temp3 ;
  
  arg1 = (std::vector< uint64_t > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (unsigned long long)jarg3; 
  arg3 = &temp3; 
  
  try {
    try {
      std_vector_Sl_uint64_t_Sg__setitem(arg1,arg2,(unsigned long long const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_uint64_t_AddRange(void * jarg1, void * jarg2) {
  std::vector< uint64_t > *arg1 = (std::vector< uint64_t > *) 0 ;
  std::vector< unsigned long long > *arg2 = 0 ;
  
  arg1 = (std::vector< uint64_t > *)jarg1; 
  arg2 = (std::vector< unsigned long long > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned long long > const & type is null", 0);
    return ;
  } 
  
  try {
    std_vector_Sl_uint64_t_Sg__AddRange(arg1,(std::vector< unsigned long long > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vector_uint64_t_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< uint64_t > *arg1 = (std::vector< uint64_t > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< unsigned long long > *result = 0 ;
  
  arg1 = (std::vector< uint64_t > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      result = (std::vector< unsigned long long > *)std_vector_Sl_uint64_t_Sg__GetRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_uint64_t_Insert(void * jarg1, int jarg2, unsigned long long jarg3) {
  std::vector< uint64_t > *arg1 = (std::vector< uint64_t > *) 0 ;
  int arg2 ;
  unsigned long long *arg3 = 0 ;
  unsigned long long temp3 ;
  
  arg1 = (std::vector< uint64_t > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (unsigned long long)jarg3; 
  arg3 = &temp3; 
  
  try {
    try {
      std_vector_Sl_uint64_t_Sg__Insert(arg1,arg2,(unsigned long long const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_uint64_t_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< uint64_t > *arg1 = (std::vector< uint64_t > *) 0 ;
  int arg2 ;
  std::vector< unsigned long long > *arg3 = 0 ;
  
  arg1 = (std::vector< uint64_t > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< unsigned long long > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned long long > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_uint64_t_Sg__InsertRange(arg1,arg2,(std::vector< unsigned long long > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_uint64_t_RemoveAt(void * jarg1, int jarg2) {
  std::vector< uint64_t > *arg1 = (std::vector< uint64_t > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< uint64_t > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      std_vector_Sl_uint64_t_Sg__RemoveAt(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_uint64_t_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< uint64_t > *arg1 = (std::vector< uint64_t > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< uint64_t > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_uint64_t_Sg__RemoveRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vector_uint64_t_Repeat(unsigned long long jarg1, int jarg2) {
  void * jresult ;
  unsigned long long *arg1 = 0 ;
  int arg2 ;
  unsigned long long temp1 ;
  std::vector< unsigned long long > *result = 0 ;
  
  temp1 = (unsigned long long)jarg1; 
  arg1 = &temp1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< unsigned long long > *)std_vector_Sl_uint64_t_Sg__Repeat((unsigned long long const &)*arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_uint64_t_Reverse__SWIG_0(void * jarg1) {
  std::vector< uint64_t > *arg1 = (std::vector< uint64_t > *) 0 ;
  
  arg1 = (std::vector< uint64_t > *)jarg1; 
  
  try {
    std_vector_Sl_uint64_t_Sg__Reverse__SWIG_0(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_uint64_t_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< uint64_t > *arg1 = (std::vector< uint64_t > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< uint64_t > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_uint64_t_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_uint64_t_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< uint64_t > *arg1 = (std::vector< uint64_t > *) 0 ;
  int arg2 ;
  std::vector< unsigned long long > *arg3 = 0 ;
  
  arg1 = (std::vector< uint64_t > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< unsigned long long > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned long long > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_uint64_t_Sg__SetRange(arg1,arg2,(std::vector< unsigned long long > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_vector_uint64_t_Contains(void * jarg1, unsigned long long jarg2) {
  unsigned int jresult ;
  std::vector< uint64_t > *arg1 = (std::vector< uint64_t > *) 0 ;
  unsigned long long *arg2 = 0 ;
  unsigned long long temp2 ;
  bool result;
  
  arg1 = (std::vector< uint64_t > *)jarg1; 
  temp2 = (unsigned long long)jarg2; 
  arg2 = &temp2; 
  
  try {
    result = (bool)std_vector_Sl_uint64_t_Sg__Contains(arg1,(unsigned long long const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_vector_uint64_t_IndexOf(void * jarg1, unsigned long long jarg2) {
  int jresult ;
  std::vector< uint64_t > *arg1 = (std::vector< uint64_t > *) 0 ;
  unsigned long long *arg2 = 0 ;
  unsigned long long temp2 ;
  int result;
  
  arg1 = (std::vector< uint64_t > *)jarg1; 
  temp2 = (unsigned long long)jarg2; 
  arg2 = &temp2; 
  
  try {
    result = (int)std_vector_Sl_uint64_t_Sg__IndexOf(arg1,(unsigned long long const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_vector_uint64_t_LastIndexOf(void * jarg1, unsigned long long jarg2) {
  int jresult ;
  std::vector< uint64_t > *arg1 = (std::vector< uint64_t > *) 0 ;
  unsigned long long *arg2 = 0 ;
  unsigned long long temp2 ;
  int result;
  
  arg1 = (std::vector< uint64_t > *)jarg1; 
  temp2 = (unsigned long long)jarg2; 
  arg2 = &temp2; 
  
  try {
    result = (int)std_vector_Sl_uint64_t_Sg__LastIndexOf(arg1,(unsigned long long const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_vector_uint64_t_Remove(void * jarg1, unsigned long long jarg2) {
  unsigned int jresult ;
  std::vector< uint64_t > *arg1 = (std::vector< uint64_t > *) 0 ;
  unsigned long long *arg2 = 0 ;
  unsigned long long temp2 ;
  bool result;
  
  arg1 = (std::vector< uint64_t > *)jarg1; 
  temp2 = (unsigned long long)jarg2; 
  arg2 = &temp2; 
  
  try {
    result = (bool)std_vector_Sl_uint64_t_Sg__Remove(arg1,(unsigned long long const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_vector_uint64_t(void * jarg1) {
  std::vector< uint64_t > *arg1 = (std::vector< uint64_t > *) 0 ;
  
  arg1 = (std::vector< uint64_t > *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_map_strstr__SWIG_0() {
  void * jresult ;
  std::map< std::string,std::string > *result = 0 ;
  
  
  try {
    result = (std::map< std::string,std::string > *)new std::map< std::string,std::string >();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_map_strstr__SWIG_1(void * jarg1) {
  void * jresult ;
  std::map< std::string,std::string > *arg1 = 0 ;
  std::map< std::string,std::string > *result = 0 ;
  
  arg1 = (std::map< std::string,std::string > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< std::string,std::string > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (std::map< std::string,std::string > *)new std::map< std::string,std::string >((std::map< std::string,std::string > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_map_strstr_size(void * jarg1) {
  unsigned long jresult ;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string >::size_type result;
  
  arg1 = (std::map< std::string,std::string > *)jarg1; 
  
  try {
    result = ((std::map< std::string,std::string > const *)arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_map_strstr_empty(void * jarg1) {
  unsigned int jresult ;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  bool result;
  
  arg1 = (std::map< std::string,std::string > *)jarg1; 
  
  try {
    result = (bool)((std::map< std::string,std::string > const *)arg1)->empty();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_map_strstr_Clear(void * jarg1) {
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  
  arg1 = (std::map< std::string,std::string > *)jarg1; 
  
  try {
    (arg1)->clear();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_map_strstr_getitem(void * jarg1, char * jarg2) {
  char * jresult ;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string >::key_type *arg2 = 0 ;
  std::map< std::string,std::string >::mapped_type *result = 0 ;
  
  arg1 = (std::map< std::string,std::string > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::map< std::string,std::string >::key_type arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    try {
      result = (std::map< std::string,std::string >::mapped_type *) &std_map_Sl_std_string_Sc_std_string_Sg__getitem(arg1,(std::string const &)*arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_map_strstr_setitem(void * jarg1, char * jarg2, char * jarg3) {
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string >::key_type *arg2 = 0 ;
  std::map< std::string,std::string >::mapped_type *arg3 = 0 ;
  
  arg1 = (std::map< std::string,std::string > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::map< std::string,std::string >::key_type arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::map< std::string,std::string >::mapped_type arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  try {
    std_map_Sl_std_string_Sc_std_string_Sg__setitem(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_map_strstr_ContainsKey(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string >::key_type *arg2 = 0 ;
  bool result;
  
  arg1 = (std::map< std::string,std::string > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::map< std::string,std::string >::key_type arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (bool)std_map_Sl_std_string_Sc_std_string_Sg__ContainsKey(arg1,(std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_map_strstr_Add(void * jarg1, char * jarg2, char * jarg3) {
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string >::key_type *arg2 = 0 ;
  std::map< std::string,std::string >::mapped_type *arg3 = 0 ;
  
  arg1 = (std::map< std::string,std::string > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::map< std::string,std::string >::key_type arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::map< std::string,std::string >::mapped_type arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  try {
    try {
      std_map_Sl_std_string_Sc_std_string_Sg__Add(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_map_strstr_Remove(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string >::key_type *arg2 = 0 ;
  bool result;
  
  arg1 = (std::map< std::string,std::string > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::map< std::string,std::string >::key_type arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (bool)std_map_Sl_std_string_Sc_std_string_Sg__Remove(arg1,(std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_map_strstr_create_iterator_begin(void * jarg1) {
  void * jresult ;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string,std::less< std::string > >::iterator *result = 0 ;
  
  arg1 = (std::map< std::string,std::string > *)jarg1; 
  
  try {
    result = (std::map< std::string,std::string,std::less< std::string > >::iterator *)std_map_Sl_std_string_Sc_std_string_Sg__create_iterator_begin(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_map_strstr_get_next_key(void * jarg1, void * jarg2) {
  char * jresult ;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string,std::less< std::string > >::iterator *arg2 = (std::map< std::string,std::string,std::less< std::string > >::iterator *) 0 ;
  std::map< std::string,std::string >::key_type *result = 0 ;
  
  arg1 = (std::map< std::string,std::string > *)jarg1; 
  arg2 = (std::map< std::string,std::string,std::less< std::string > >::iterator *)jarg2; 
  
  try {
    result = (std::map< std::string,std::string >::key_type *) &std_map_Sl_std_string_Sc_std_string_Sg__get_next_key(arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_map_strstr_destroy_iterator(void * jarg1, void * jarg2) {
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string,std::less< std::string > >::iterator *arg2 = (std::map< std::string,std::string,std::less< std::string > >::iterator *) 0 ;
  
  arg1 = (std::map< std::string,std::string > *)jarg1; 
  arg2 = (std::map< std::string,std::string,std::less< std::string > >::iterator *)jarg2; 
  
  try {
    std_map_Sl_std_string_Sc_std_string_Sg__destroy_iterator(arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_map_strstr(void * jarg1) {
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  
  arg1 = (std::map< std::string,std::string > *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_GetRRDataTypeString(int jarg1) {
  char * jresult ;
  RobotRaconteur::DataTypes arg1 ;
  std::string result;
  
  arg1 = (RobotRaconteur::DataTypes)jarg1; 
  
  try {
    result = RobotRaconteur::GetRRDataTypeString(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_IsTypeRRArray(int jarg1) {
  unsigned int jresult ;
  RobotRaconteur::DataTypes arg1 ;
  bool result;
  
  arg1 = (RobotRaconteur::DataTypes)jarg1; 
  
  try {
    result = (bool)RobotRaconteur::IsTypeRRArray(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_IsTypeNumeric(int jarg1) {
  unsigned int jresult ;
  RobotRaconteur::DataTypes arg1 ;
  bool result;
  
  arg1 = (RobotRaconteur::DataTypes)jarg1; 
  
  try {
    result = (bool)RobotRaconteur::IsTypeNumeric(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_RRObject(void * jarg1) {
  RobotRaconteur::RRObject *arg1 = (RobotRaconteur::RRObject *) 0 ;
  boost::shared_ptr< RobotRaconteur::RRObject > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RRObject > *)jarg1;
  arg1 = (RobotRaconteur::RRObject *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_RRValue(void * jarg1) {
  RobotRaconteur::RRValue *arg1 = (RobotRaconteur::RRValue *) 0 ;
  boost::shared_ptr< RobotRaconteur::RRValue > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::RRValue > **)&jarg1;
  arg1 = (RobotRaconteur::RRValue *)(smartarg1 ? smartarg1->get() : 0);
  
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_MessageElementData_GetTypeString(void * jarg1) {
  char * jresult ;
  RobotRaconteur::MessageElementData *arg1 = (RobotRaconteur::MessageElementData *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementData > *smartarg1 = 0 ;
  RobotRaconteur::MessageStringPtr result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElementData > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElementData *)(smartarg1 ? smartarg1->get() : 0);
  
  
  try {
    result = (arg1)->GetTypeString();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  std::string temp_ret1 = (&result)->str().to_string(); jresult = SWIG_csharp_string_callback(temp_ret1.c_str()); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_MessageElementData_GetTypeID(void * jarg1) {
  int jresult ;
  RobotRaconteur::MessageElementData *arg1 = (RobotRaconteur::MessageElementData *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementData > *smartarg1 = 0 ;
  RobotRaconteur::DataTypes result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElementData > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElementData *)(smartarg1 ? smartarg1->get() : 0);
  
  
  try {
    result = (RobotRaconteur::DataTypes)(arg1)->GetTypeID();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_MessageElementData(void * jarg1) {
  RobotRaconteur::MessageElementData *arg1 = (RobotRaconteur::MessageElementData *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementData > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElementData > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElementData *)(smartarg1 ? smartarg1->get() : 0);
  
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_RRBaseArray_GetTypeString(void * jarg1) {
  char * jresult ;
  RobotRaconteur::RRBaseArray *arg1 = (RobotRaconteur::RRBaseArray *) 0 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg1 = 0 ;
  RobotRaconteur::MessageStringPtr result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jarg1;
  arg1 = (RobotRaconteur::RRBaseArray *)(smartarg1 ? smartarg1->get() : 0);
  
  
  try {
    result = (arg1)->GetTypeString();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  std::string temp_ret1 = (&result)->str().to_string(); jresult = SWIG_csharp_string_callback(temp_ret1.c_str()); 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_RRBaseArray_size(void * jarg1) {
  unsigned long jresult ;
  RobotRaconteur::RRBaseArray *arg1 = (RobotRaconteur::RRBaseArray *) 0 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg1 = 0 ;
  size_t result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jarg1;
  arg1 = (RobotRaconteur::RRBaseArray *)(smartarg1 ? smartarg1->get() : 0);
  
  
  try {
    result = (arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RRBaseArray_void_ptr(void * jarg1) {
  void * jresult ;
  RobotRaconteur::RRBaseArray *arg1 = (RobotRaconteur::RRBaseArray *) 0 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg1 = 0 ;
  void *result = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jarg1;
  arg1 = (RobotRaconteur::RRBaseArray *)(smartarg1 ? smartarg1->get() : 0);
  
  
  try {
    result = (void *)(arg1)->void_ptr();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_RRBaseArray_ElementSize(void * jarg1) {
  unsigned long jresult ;
  RobotRaconteur::RRBaseArray *arg1 = (RobotRaconteur::RRBaseArray *) 0 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg1 = 0 ;
  size_t result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jarg1;
  arg1 = (RobotRaconteur::RRBaseArray *)(smartarg1 ? smartarg1->get() : 0);
  
  
  try {
    result = (arg1)->ElementSize();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_RRBaseArray_GetTypeID(void * jarg1) {
  int jresult ;
  RobotRaconteur::RRBaseArray *arg1 = (RobotRaconteur::RRBaseArray *) 0 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg1 = 0 ;
  RobotRaconteur::DataTypes result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jarg1;
  arg1 = (RobotRaconteur::RRBaseArray *)(smartarg1 ? smartarg1->get() : 0);
  
  
  try {
    result = (RobotRaconteur::DataTypes)(arg1)->GetTypeID();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_RRBaseArray(void * jarg1) {
  RobotRaconteur::RRBaseArray *arg1 = (RobotRaconteur::RRBaseArray *) 0 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jarg1;
  arg1 = (RobotRaconteur::RRBaseArray *)(smartarg1 ? smartarg1->get() : 0);
  
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_AllocateRRArrayByType(int jarg1, unsigned long jarg2) {
  void * jresult ;
  RobotRaconteur::DataTypes arg1 ;
  size_t arg2 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > result;
  
  arg1 = (RobotRaconteur::DataTypes)jarg1; 
  arg2 = (size_t)jarg2; 
  
  try {
    result = RobotRaconteur::AllocateRRArrayByType(arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = new boost::shared_ptr<  RobotRaconteur::RRBaseArray >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::RRBaseArray >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RRMultiDimArrayUntyped_Dims_set(void * jarg1, void * jarg2) {
  RobotRaconteur::RRMultiDimArrayUntyped *arg1 = (RobotRaconteur::RRMultiDimArrayUntyped *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RRMultiDimArrayUntyped > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp2 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RRMultiDimArrayUntyped > *)jarg1;
  arg1 = (RobotRaconteur::RRMultiDimArrayUntyped *)(smartarg1 ? smartarg1->get() : 0); 
  
  // intrusive_ptr by reference
  if ( jarg2 ) {
    smartarg2 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg2;
    temp2 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg2->get(), true);
    arg2 = &temp2;
  } else {
    arg2 = &tempnull2;
  }
  
  if (arg1) (arg1)->Dims = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RRMultiDimArrayUntyped_Dims_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::RRMultiDimArrayUntyped *arg1 = (RobotRaconteur::RRMultiDimArrayUntyped *) 0 ;
  boost::shared_ptr< RobotRaconteur::RRMultiDimArrayUntyped > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RRMultiDimArrayUntyped > *)jarg1;
  arg1 = (RobotRaconteur::RRMultiDimArrayUntyped *)(smartarg1 ? smartarg1->get() : 0); 
  result = (boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *) & ((arg1)->Dims);
  
  if (*result) {
    intrusive_ptr_add_ref(result->get());
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = new boost::shared_ptr<  RobotRaconteur::RRBaseArray >(result->get(), SWIG_intrusive_deleter<  RobotRaconteur::RRBaseArray >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RRMultiDimArrayUntyped_Array_set(void * jarg1, void * jarg2) {
  RobotRaconteur::RRMultiDimArrayUntyped *arg1 = (RobotRaconteur::RRMultiDimArrayUntyped *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RRMultiDimArrayUntyped > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp2 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RRMultiDimArrayUntyped > *)jarg1;
  arg1 = (RobotRaconteur::RRMultiDimArrayUntyped *)(smartarg1 ? smartarg1->get() : 0); 
  
  // intrusive_ptr by reference
  if ( jarg2 ) {
    smartarg2 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg2;
    temp2 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg2->get(), true);
    arg2 = &temp2;
  } else {
    arg2 = &tempnull2;
  }
  
  if (arg1) (arg1)->Array = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RRMultiDimArrayUntyped_Array_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::RRMultiDimArrayUntyped *arg1 = (RobotRaconteur::RRMultiDimArrayUntyped *) 0 ;
  boost::shared_ptr< RobotRaconteur::RRMultiDimArrayUntyped > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RRMultiDimArrayUntyped > *)jarg1;
  arg1 = (RobotRaconteur::RRMultiDimArrayUntyped *)(smartarg1 ? smartarg1->get() : 0); 
  result = (boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *) & ((arg1)->Array);
  
  if (*result) {
    intrusive_ptr_add_ref(result->get());
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = new boost::shared_ptr<  RobotRaconteur::RRBaseArray >(result->get(), SWIG_intrusive_deleter<  RobotRaconteur::RRBaseArray >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_RRMultiDimArrayUntyped() {
  void * jresult ;
  RobotRaconteur::RRMultiDimArrayUntyped *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::RRMultiDimArrayUntyped *)new RobotRaconteur::RRMultiDimArrayUntyped();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::RRMultiDimArrayUntyped >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_RRMultiDimArrayUntyped(void * jarg1) {
  RobotRaconteur::RRMultiDimArrayUntyped *arg1 = (RobotRaconteur::RRMultiDimArrayUntyped *) 0 ;
  boost::shared_ptr< RobotRaconteur::RRMultiDimArrayUntyped > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RRMultiDimArrayUntyped > *)jarg1;
  arg1 = (RobotRaconteur::RRMultiDimArrayUntyped *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_ServicePathSegment__SWIG_0() {
  void * jresult ;
  RobotRaconteur::ServicePathSegment *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::ServicePathSegment *)new RobotRaconteur::ServicePathSegment();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_ServicePathSegment__SWIG_1(char * jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  RobotRaconteur::ServicePathSegment *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  
  try {
    result = (RobotRaconteur::ServicePathSegment *)new RobotRaconteur::ServicePathSegment((std::string const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_ServicePathSegment__SWIG_2(char * jarg1, char * jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  RobotRaconteur::ServicePathSegment *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (RobotRaconteur::ServicePathSegment *)new RobotRaconteur::ServicePathSegment((std::string const &)*arg1,(std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServicePathSegment_name_set(void * jarg1, char * jarg2) {
  RobotRaconteur::ServicePathSegment *arg1 = (RobotRaconteur::ServicePathSegment *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::ServicePathSegment *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->name = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ServicePathSegment_name_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::ServicePathSegment *arg1 = (RobotRaconteur::ServicePathSegment *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (RobotRaconteur::ServicePathSegment *)jarg1; 
  result = (std::string *) & ((arg1)->name);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServicePathSegment_index_set(void * jarg1, void * jarg2) {
  RobotRaconteur::ServicePathSegment *arg1 = (RobotRaconteur::ServicePathSegment *) 0 ;
  boost::optional< std::string > *arg2 = (boost::optional< std::string > *) 0 ;
  
  arg1 = (RobotRaconteur::ServicePathSegment *)jarg1; 
  arg2 = (boost::optional< std::string > *)jarg2; 
  if (arg1) (arg1)->index = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServicePathSegment_index_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ServicePathSegment *arg1 = (RobotRaconteur::ServicePathSegment *) 0 ;
  boost::optional< std::string > *result = 0 ;
  
  arg1 = (RobotRaconteur::ServicePathSegment *)jarg1; 
  result = (boost::optional< std::string > *)& ((arg1)->index);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_ServicePathSegment(void * jarg1) {
  RobotRaconteur::ServicePathSegment *arg1 = (RobotRaconteur::ServicePathSegment *) 0 ;
  
  arg1 = (RobotRaconteur::ServicePathSegment *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServicePathSegments_Clear(void * jarg1) {
  std::vector< RobotRaconteur::ServicePathSegment > *arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *) 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *)jarg1; 
  
  try {
    (arg1)->clear();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServicePathSegments_Add(void * jarg1, void * jarg2) {
  std::vector< RobotRaconteur::ServicePathSegment > *arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *) 0 ;
  RobotRaconteur::ServicePathSegment *arg2 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *)jarg1; 
  arg2 = (RobotRaconteur::ServicePathSegment *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::ServicePathSegment const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->push_back((RobotRaconteur::ServicePathSegment const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_ServicePathSegments_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< RobotRaconteur::ServicePathSegment > *arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *) 0 ;
  std::vector< RobotRaconteur::ServicePathSegment >::size_type result;
  
  arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *)jarg1; 
  
  try {
    result = ((std::vector< RobotRaconteur::ServicePathSegment > const *)arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_ServicePathSegments_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< RobotRaconteur::ServicePathSegment > *arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *) 0 ;
  std::vector< RobotRaconteur::ServicePathSegment >::size_type result;
  
  arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *)jarg1; 
  
  try {
    result = ((std::vector< RobotRaconteur::ServicePathSegment > const *)arg1)->capacity();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServicePathSegments_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< RobotRaconteur::ServicePathSegment > *arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *) 0 ;
  std::vector< RobotRaconteur::ServicePathSegment >::size_type arg2 ;
  
  arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *)jarg1; 
  arg2 = (std::vector< RobotRaconteur::ServicePathSegment >::size_type)jarg2; 
  
  try {
    (arg1)->reserve(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_ServicePathSegments__SWIG_0() {
  void * jresult ;
  std::vector< RobotRaconteur::ServicePathSegment > *result = 0 ;
  
  
  try {
    result = (std::vector< RobotRaconteur::ServicePathSegment > *)new std::vector< RobotRaconteur::ServicePathSegment >();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_ServicePathSegments__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< RobotRaconteur::ServicePathSegment > *arg1 = 0 ;
  std::vector< RobotRaconteur::ServicePathSegment > *result = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::ServicePathSegment > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (std::vector< RobotRaconteur::ServicePathSegment > *)new std::vector< RobotRaconteur::ServicePathSegment >((std::vector< RobotRaconteur::ServicePathSegment > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_ServicePathSegments__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< RobotRaconteur::ServicePathSegment > *result = 0 ;
  
  arg1 = (int)jarg1; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::ServicePathSegment > *)new_std_vector_Sl_RobotRaconteur_ServicePathSegment_Sg___SWIG_2(arg1);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServicePathSegments_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< RobotRaconteur::ServicePathSegment > *arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *) 0 ;
  int arg2 ;
  RobotRaconteur::ServicePathSegment result;
  
  arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = std_vector_Sl_RobotRaconteur_ServicePathSegment_Sg__getitemcopy(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::ServicePathSegment((const RobotRaconteur::ServicePathSegment &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServicePathSegments_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< RobotRaconteur::ServicePathSegment > *arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *) 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::ServicePathSegment >::value_type *result = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::ServicePathSegment >::value_type *) &std_vector_Sl_RobotRaconteur_ServicePathSegment_Sg__getitem(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServicePathSegments_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::ServicePathSegment > *arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *) 0 ;
  int arg2 ;
  RobotRaconteur::ServicePathSegment *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (RobotRaconteur::ServicePathSegment *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::ServicePathSegment const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ServicePathSegment_Sg__setitem(arg1,arg2,(RobotRaconteur::ServicePathSegment const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServicePathSegments_AddRange(void * jarg1, void * jarg2) {
  std::vector< RobotRaconteur::ServicePathSegment > *arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *) 0 ;
  std::vector< RobotRaconteur::ServicePathSegment > *arg2 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *)jarg1; 
  arg2 = (std::vector< RobotRaconteur::ServicePathSegment > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::ServicePathSegment > const & type is null", 0);
    return ;
  } 
  
  try {
    std_vector_Sl_RobotRaconteur_ServicePathSegment_Sg__AddRange(arg1,(std::vector< RobotRaconteur::ServicePathSegment > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServicePathSegments_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< RobotRaconteur::ServicePathSegment > *arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< RobotRaconteur::ServicePathSegment > *result = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::ServicePathSegment > *)std_vector_Sl_RobotRaconteur_ServicePathSegment_Sg__GetRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServicePathSegments_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::ServicePathSegment > *arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *) 0 ;
  int arg2 ;
  RobotRaconteur::ServicePathSegment *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (RobotRaconteur::ServicePathSegment *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::ServicePathSegment const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ServicePathSegment_Sg__Insert(arg1,arg2,(RobotRaconteur::ServicePathSegment const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServicePathSegments_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::ServicePathSegment > *arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *) 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::ServicePathSegment > *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< RobotRaconteur::ServicePathSegment > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::ServicePathSegment > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ServicePathSegment_Sg__InsertRange(arg1,arg2,(std::vector< RobotRaconteur::ServicePathSegment > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServicePathSegments_RemoveAt(void * jarg1, int jarg2) {
  std::vector< RobotRaconteur::ServicePathSegment > *arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ServicePathSegment_Sg__RemoveAt(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServicePathSegments_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< RobotRaconteur::ServicePathSegment > *arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ServicePathSegment_Sg__RemoveRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServicePathSegments_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  RobotRaconteur::ServicePathSegment *arg1 = 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::ServicePathSegment > *result = 0 ;
  
  arg1 = (RobotRaconteur::ServicePathSegment *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::ServicePathSegment const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::ServicePathSegment > *)std_vector_Sl_RobotRaconteur_ServicePathSegment_Sg__Repeat((RobotRaconteur::ServicePathSegment const &)*arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServicePathSegments_Reverse__SWIG_0(void * jarg1) {
  std::vector< RobotRaconteur::ServicePathSegment > *arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *) 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *)jarg1; 
  
  try {
    std_vector_Sl_RobotRaconteur_ServicePathSegment_Sg__Reverse__SWIG_0(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServicePathSegments_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< RobotRaconteur::ServicePathSegment > *arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ServicePathSegment_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServicePathSegments_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::ServicePathSegment > *arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *) 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::ServicePathSegment > *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< RobotRaconteur::ServicePathSegment > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::ServicePathSegment > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ServicePathSegment_Sg__SetRange(arg1,arg2,(std::vector< RobotRaconteur::ServicePathSegment > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_ServicePathSegments(void * jarg1) {
  std::vector< RobotRaconteur::ServicePathSegment > *arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *) 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_EncodeServicePathIndex(char * jarg1) {
  char * jresult ;
  std::string *arg1 = 0 ;
  std::string result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  
  try {
    result = RobotRaconteur::EncodeServicePathIndex((std::string const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_DecodeServicePathIndex(char * jarg1) {
  char * jresult ;
  std::string *arg1 = 0 ;
  std::string result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  
  try {
    result = RobotRaconteur::DecodeServicePathIndex((std::string const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ParseServicePath(char * jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::vector< RobotRaconteur::ServicePathSegment > result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  
  try {
    result = RobotRaconteur::ParseServicePath((std::string const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< RobotRaconteur::ServicePathSegment >((const std::vector< RobotRaconteur::ServicePathSegment > &)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_BuildServicePath(void * jarg1) {
  char * jresult ;
  std::vector< RobotRaconteur::ServicePathSegment > *arg1 = 0 ;
  std::string result;
  
  arg1 = (std::vector< RobotRaconteur::ServicePathSegment > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::ServicePathSegment > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = RobotRaconteur::BuildServicePath((std::vector< RobotRaconteur::ServicePathSegment > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_IsStringName(void * jarg1) {
  unsigned int jresult ;
  boost::string_ref arg1 ;
  boost::string_ref *argp1 ;
  bool result;
  
  argp1 = (boost::string_ref *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null boost::string_ref", 0);
    return 0;
  }
  arg1 = *argp1; 
  
  try {
    result = (bool)RobotRaconteur::IsStringName(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_IsStringScopedName(void * jarg1) {
  unsigned int jresult ;
  boost::string_ref arg1 ;
  boost::string_ref *argp1 ;
  bool result;
  
  argp1 = (boost::string_ref *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null boost::string_ref", 0);
    return 0;
  }
  arg1 = *argp1; 
  
  try {
    result = (bool)RobotRaconteur::IsStringScopedName(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_IsStringUUID(void * jarg1) {
  unsigned int jresult ;
  boost::string_ref arg1 ;
  boost::string_ref *argp1 ;
  bool result;
  
  argp1 = (boost::string_ref *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null boost::string_ref", 0);
    return 0;
  }
  arg1 = *argp1; 
  
  try {
    result = (bool)RobotRaconteur::IsStringUUID(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_IsStringIdentifier(void * jarg1) {
  unsigned int jresult ;
  boost::string_ref arg1 ;
  boost::string_ref *argp1 ;
  bool result;
  
  argp1 = (boost::string_ref *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null boost::string_ref", 0);
    return 0;
  }
  arg1 = *argp1; 
  
  try {
    result = (bool)RobotRaconteur::IsStringIdentifier(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_MultiDimArray_CalculateCopyIndicesIter_Next(void * jarg1, unsigned int * jarg2, unsigned int * jarg3, unsigned int * jarg4) {
  unsigned int jresult ;
  RobotRaconteur::detail::MultiDimArray_CalculateCopyIndicesIter *arg1 = (RobotRaconteur::detail::MultiDimArray_CalculateCopyIndicesIter *) 0 ;
  uint32_t *arg2 = 0 ;
  uint32_t *arg3 = 0 ;
  uint32_t *arg4 = 0 ;
  boost::shared_ptr< RobotRaconteur::detail::MultiDimArray_CalculateCopyIndicesIter > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::detail::MultiDimArray_CalculateCopyIndicesIter > *)jarg1;
  arg1 = (RobotRaconteur::detail::MultiDimArray_CalculateCopyIndicesIter *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (uint32_t *)jarg2; 
  arg3 = (uint32_t *)jarg3; 
  arg4 = (uint32_t *)jarg4; 
  
  try {
    result = (bool)(arg1)->Next(*arg2,*arg3,*arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_MultiDimArray_CalculateCopyIndicesIter(void * jarg1) {
  RobotRaconteur::detail::MultiDimArray_CalculateCopyIndicesIter *arg1 = (RobotRaconteur::detail::MultiDimArray_CalculateCopyIndicesIter *) 0 ;
  boost::shared_ptr< RobotRaconteur::detail::MultiDimArray_CalculateCopyIndicesIter > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::detail::MultiDimArray_CalculateCopyIndicesIter > *)jarg1;
  arg1 = (RobotRaconteur::detail::MultiDimArray_CalculateCopyIndicesIter *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MultiDimArray_CalculateCopyIndicesBeginIter(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  std::vector< uint32_t > *arg1 = 0 ;
  std::vector< uint32_t > *arg2 = 0 ;
  std::vector< uint32_t > *arg3 = 0 ;
  std::vector< uint32_t > *arg4 = 0 ;
  std::vector< uint32_t > *arg5 = 0 ;
  boost::shared_ptr< RobotRaconteur::detail::MultiDimArray_CalculateCopyIndicesIter > result;
  
  arg1 = (std::vector< uint32_t > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint32_t > const & type is null", 0);
    return 0;
  } 
  arg2 = (std::vector< uint32_t > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint32_t > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< uint32_t > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint32_t > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< uint32_t > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint32_t > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< uint32_t > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint32_t > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = RobotRaconteur::detail::MultiDimArray_CalculateCopyIndicesBeginIter((std::vector< unsigned int > const &)*arg1,(std::vector< unsigned int > const &)*arg2,(std::vector< unsigned int > const &)*arg3,(std::vector< unsigned int > const &)*arg4,(std::vector< unsigned int > const &)*arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::detail::MultiDimArray_CalculateCopyIndicesIter >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_typedefinition_Clear(void * jarg1) {
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)jarg1; 
  
  try {
    (arg1)->clear();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_typedefinition_Add(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > tempnull2 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::TypeDefinition > *)jarg2 : &tempnull2; 
  
  try {
    (arg1)->push_back((boost::shared_ptr< RobotRaconteur::TypeDefinition > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_typedefinition_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)jarg1; 
  
  try {
    result = ((std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > const *)arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_typedefinition_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)jarg1; 
  
  try {
    result = ((std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > const *)arg1)->capacity();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_typedefinition_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > >::size_type arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > >::size_type)jarg2; 
  
  try {
    (arg1)->reserve(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_typedefinition__SWIG_0() {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *result = 0 ;
  
  
  try {
    result = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)new std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > >();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_typedefinition__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *arg1 = 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)new std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > >((std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_typedefinition__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)new_std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_TypeDefinition_Sg__Sg___SWIG_2(arg1);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_typedefinition_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > result;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_TypeDefinition_Sg__Sg__getitemcopy(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::TypeDefinition >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_typedefinition_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > >::value_type *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > >::value_type *) &std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_TypeDefinition_Sg__Sg__getitem(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = *result ? new std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > >::value_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_typedefinition_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > tempnull3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (boost::shared_ptr< RobotRaconteur::TypeDefinition > *)jarg3 : &tempnull3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_TypeDefinition_Sg__Sg__setitem(arg1,arg2,(boost::shared_ptr< RobotRaconteur::TypeDefinition > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_typedefinition_AddRange(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > const & type is null", 0);
    return ;
  } 
  
  try {
    std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_TypeDefinition_Sg__Sg__AddRange(arg1,(std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_typedefinition_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_TypeDefinition_Sg__Sg__GetRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_typedefinition_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > tempnull3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (boost::shared_ptr< RobotRaconteur::TypeDefinition > *)jarg3 : &tempnull3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_TypeDefinition_Sg__Sg__Insert(arg1,arg2,(boost::shared_ptr< RobotRaconteur::TypeDefinition > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_typedefinition_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_TypeDefinition_Sg__Sg__InsertRange(arg1,arg2,(std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_typedefinition_RemoveAt(void * jarg1, int jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_TypeDefinition_Sg__Sg__RemoveAt(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_typedefinition_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_TypeDefinition_Sg__Sg__RemoveRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_typedefinition_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *arg1 = 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > tempnull1 ;
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::TypeDefinition > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_TypeDefinition_Sg__Sg__Repeat((boost::shared_ptr< RobotRaconteur::TypeDefinition > const &)*arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_typedefinition_Reverse__SWIG_0(void * jarg1) {
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)jarg1; 
  
  try {
    std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_TypeDefinition_Sg__Sg__Reverse__SWIG_0(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_typedefinition_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_TypeDefinition_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_typedefinition_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_TypeDefinition_Sg__Sg__SetRange(arg1,arg2,(std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_vectorptr_typedefinition(void * jarg1) {
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_memberdefinition_Clear(void * jarg1) {
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *)jarg1; 
  
  try {
    (arg1)->clear();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_memberdefinition_Add(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *) 0 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > tempnull2 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::MemberDefinition > *)jarg2 : &tempnull2; 
  
  try {
    (arg1)->push_back((boost::shared_ptr< RobotRaconteur::MemberDefinition > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_memberdefinition_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *)jarg1; 
  
  try {
    result = ((std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > const *)arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_memberdefinition_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *)jarg1; 
  
  try {
    result = ((std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > const *)arg1)->capacity();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_memberdefinition_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > >::size_type arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > >::size_type)jarg2; 
  
  try {
    (arg1)->reserve(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_memberdefinition__SWIG_0() {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *result = 0 ;
  
  
  try {
    result = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *)new std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > >();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_memberdefinition__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *arg1 = 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *)new std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > >((std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_memberdefinition__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *)new_std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_MemberDefinition_Sg__Sg___SWIG_2(arg1);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_memberdefinition__getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > result;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_MemberDefinition_Sg__Sg__getitemcopy(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::MemberDefinition >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_memberdefinition__getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > >::value_type *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > >::value_type *) &std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_MemberDefinition_Sg__Sg__getitem(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = *result ? new std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > >::value_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_memberdefinition_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > tempnull3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (boost::shared_ptr< RobotRaconteur::MemberDefinition > *)jarg3 : &tempnull3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_MemberDefinition_Sg__Sg__setitem(arg1,arg2,(boost::shared_ptr< RobotRaconteur::MemberDefinition > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_memberdefinition_AddRange(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > const & type is null", 0);
    return ;
  } 
  
  try {
    std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_MemberDefinition_Sg__Sg__AddRange(arg1,(std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_memberdefinition_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *)std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_MemberDefinition_Sg__Sg__GetRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_memberdefinition_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > tempnull3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (boost::shared_ptr< RobotRaconteur::MemberDefinition > *)jarg3 : &tempnull3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_MemberDefinition_Sg__Sg__Insert(arg1,arg2,(boost::shared_ptr< RobotRaconteur::MemberDefinition > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_memberdefinition_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_MemberDefinition_Sg__Sg__InsertRange(arg1,arg2,(std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_memberdefinition_RemoveAt(void * jarg1, int jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_MemberDefinition_Sg__Sg__RemoveAt(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_memberdefinition_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_MemberDefinition_Sg__Sg__RemoveRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_memberdefinition_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > *arg1 = 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > tempnull1 ;
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::MemberDefinition > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *)std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_MemberDefinition_Sg__Sg__Repeat((boost::shared_ptr< RobotRaconteur::MemberDefinition > const &)*arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_memberdefinition_Reverse__SWIG_0(void * jarg1) {
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *)jarg1; 
  
  try {
    std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_MemberDefinition_Sg__Sg__Reverse__SWIG_0(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_memberdefinition_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_MemberDefinition_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_memberdefinition_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_MemberDefinition_Sg__Sg__SetRange(arg1,arg2,(std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_vectorptr_memberdefinition(void * jarg1) {
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_serviceentrydefinition_Clear(void * jarg1) {
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)jarg1; 
  
  try {
    (arg1)->clear();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_serviceentrydefinition_Add(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > tempnull2 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *)jarg2 : &tempnull2; 
  
  try {
    (arg1)->push_back((boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_serviceentrydefinition_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)jarg1; 
  
  try {
    result = ((std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > const *)arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_serviceentrydefinition_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)jarg1; 
  
  try {
    result = ((std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > const *)arg1)->capacity();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_serviceentrydefinition_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > >::size_type arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > >::size_type)jarg2; 
  
  try {
    (arg1)->reserve(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_serviceentrydefinition__SWIG_0() {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *result = 0 ;
  
  
  try {
    result = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)new std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > >();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_serviceentrydefinition__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *arg1 = 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)new std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > >((std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_serviceentrydefinition__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)new_std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceEntryDefinition_Sg__Sg___SWIG_2(arg1);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_serviceentrydefinition_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > result;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceEntryDefinition_Sg__Sg__getitemcopy(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_serviceentrydefinition_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > >::value_type *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > >::value_type *) &std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceEntryDefinition_Sg__Sg__getitem(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = *result ? new std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > >::value_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_serviceentrydefinition_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > tempnull3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *)jarg3 : &tempnull3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceEntryDefinition_Sg__Sg__setitem(arg1,arg2,(boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_serviceentrydefinition_AddRange(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > const & type is null", 0);
    return ;
  } 
  
  try {
    std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceEntryDefinition_Sg__Sg__AddRange(arg1,(std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_serviceentrydefinition_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceEntryDefinition_Sg__Sg__GetRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_serviceentrydefinition_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > tempnull3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *)jarg3 : &tempnull3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceEntryDefinition_Sg__Sg__Insert(arg1,arg2,(boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_serviceentrydefinition_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceEntryDefinition_Sg__Sg__InsertRange(arg1,arg2,(std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_serviceentrydefinition_RemoveAt(void * jarg1, int jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceEntryDefinition_Sg__Sg__RemoveAt(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_serviceentrydefinition_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceEntryDefinition_Sg__Sg__RemoveRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_serviceentrydefinition_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *arg1 = 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > tempnull1 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceEntryDefinition_Sg__Sg__Repeat((boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > const &)*arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_serviceentrydefinition_Reverse__SWIG_0(void * jarg1) {
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)jarg1; 
  
  try {
    std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceEntryDefinition_Sg__Sg__Reverse__SWIG_0(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_serviceentrydefinition_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceEntryDefinition_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_serviceentrydefinition_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceEntryDefinition_Sg__Sg__SetRange(arg1,arg2,(std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_vectorptr_serviceentrydefinition(void * jarg1) {
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_constantdefinition_Clear(void * jarg1) {
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)jarg1; 
  
  try {
    (arg1)->clear();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_constantdefinition_Add(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *) 0 ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > tempnull2 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::ConstantDefinition > *)jarg2 : &tempnull2; 
  
  try {
    (arg1)->push_back((boost::shared_ptr< RobotRaconteur::ConstantDefinition > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_constantdefinition_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)jarg1; 
  
  try {
    result = ((std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > const *)arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_constantdefinition_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)jarg1; 
  
  try {
    result = ((std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > const *)arg1)->capacity();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_constantdefinition_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > >::size_type arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > >::size_type)jarg2; 
  
  try {
    (arg1)->reserve(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_constantdefinition__SWIG_0() {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *result = 0 ;
  
  
  try {
    result = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)new std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > >();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_constantdefinition__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *arg1 = 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)new std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > >((std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_constantdefinition__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)new_std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ConstantDefinition_Sg__Sg___SWIG_2(arg1);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_constantdefinition_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > result;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ConstantDefinition_Sg__Sg__getitemcopy(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::ConstantDefinition >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_constantdefinition_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > >::value_type *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > >::value_type *) &std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ConstantDefinition_Sg__Sg__getitem(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = *result ? new std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > >::value_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_constantdefinition_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > tempnull3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (boost::shared_ptr< RobotRaconteur::ConstantDefinition > *)jarg3 : &tempnull3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ConstantDefinition_Sg__Sg__setitem(arg1,arg2,(boost::shared_ptr< RobotRaconteur::ConstantDefinition > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_constantdefinition_AddRange(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > const & type is null", 0);
    return ;
  } 
  
  try {
    std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ConstantDefinition_Sg__Sg__AddRange(arg1,(std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_constantdefinition_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ConstantDefinition_Sg__Sg__GetRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_constantdefinition_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > tempnull3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (boost::shared_ptr< RobotRaconteur::ConstantDefinition > *)jarg3 : &tempnull3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ConstantDefinition_Sg__Sg__Insert(arg1,arg2,(boost::shared_ptr< RobotRaconteur::ConstantDefinition > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_constantdefinition_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ConstantDefinition_Sg__Sg__InsertRange(arg1,arg2,(std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_constantdefinition_RemoveAt(void * jarg1, int jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ConstantDefinition_Sg__Sg__RemoveAt(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_constantdefinition_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ConstantDefinition_Sg__Sg__RemoveRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_constantdefinition_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > *arg1 = 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > tempnull1 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::ConstantDefinition > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ConstantDefinition_Sg__Sg__Repeat((boost::shared_ptr< RobotRaconteur::ConstantDefinition > const &)*arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_constantdefinition_Reverse__SWIG_0(void * jarg1) {
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)jarg1; 
  
  try {
    std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ConstantDefinition_Sg__Sg__Reverse__SWIG_0(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_constantdefinition_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ConstantDefinition_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_constantdefinition_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ConstantDefinition_Sg__Sg__SetRange(arg1,arg2,(std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_vectorptr_constantdefinition(void * jarg1) {
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_enumdefinition_Clear(void * jarg1) {
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *)jarg1; 
  
  try {
    (arg1)->clear();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_enumdefinition_Add(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *) 0 ;
  boost::shared_ptr< RobotRaconteur::EnumDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::EnumDefinition > tempnull2 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::EnumDefinition > *)jarg2 : &tempnull2; 
  
  try {
    (arg1)->push_back((boost::shared_ptr< RobotRaconteur::EnumDefinition > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_enumdefinition_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *)jarg1; 
  
  try {
    result = ((std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > const *)arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_enumdefinition_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *)jarg1; 
  
  try {
    result = ((std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > const *)arg1)->capacity();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_enumdefinition_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > >::size_type arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > >::size_type)jarg2; 
  
  try {
    (arg1)->reserve(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_enumdefinition__SWIG_0() {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *result = 0 ;
  
  
  try {
    result = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *)new std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > >();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_enumdefinition__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *arg1 = 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *)new std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > >((std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_enumdefinition__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *)new_std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_EnumDefinition_Sg__Sg___SWIG_2(arg1);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_enumdefinition_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::EnumDefinition > result;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_EnumDefinition_Sg__Sg__getitemcopy(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::EnumDefinition >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_enumdefinition_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > >::value_type *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > >::value_type *) &std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_EnumDefinition_Sg__Sg__getitem(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = *result ? new std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > >::value_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_enumdefinition_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::EnumDefinition > *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::EnumDefinition > tempnull3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (boost::shared_ptr< RobotRaconteur::EnumDefinition > *)jarg3 : &tempnull3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_EnumDefinition_Sg__Sg__setitem(arg1,arg2,(boost::shared_ptr< RobotRaconteur::EnumDefinition > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_enumdefinition_AddRange(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > const & type is null", 0);
    return ;
  } 
  
  try {
    std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_EnumDefinition_Sg__Sg__AddRange(arg1,(std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_enumdefinition_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *)std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_EnumDefinition_Sg__Sg__GetRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_enumdefinition_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::EnumDefinition > *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::EnumDefinition > tempnull3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (boost::shared_ptr< RobotRaconteur::EnumDefinition > *)jarg3 : &tempnull3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_EnumDefinition_Sg__Sg__Insert(arg1,arg2,(boost::shared_ptr< RobotRaconteur::EnumDefinition > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_enumdefinition_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_EnumDefinition_Sg__Sg__InsertRange(arg1,arg2,(std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_enumdefinition_RemoveAt(void * jarg1, int jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_EnumDefinition_Sg__Sg__RemoveAt(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_enumdefinition_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_EnumDefinition_Sg__Sg__RemoveRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_enumdefinition_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::EnumDefinition > *arg1 = 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::EnumDefinition > tempnull1 ;
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::EnumDefinition > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *)std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_EnumDefinition_Sg__Sg__Repeat((boost::shared_ptr< RobotRaconteur::EnumDefinition > const &)*arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_enumdefinition_Reverse__SWIG_0(void * jarg1) {
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *)jarg1; 
  
  try {
    std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_EnumDefinition_Sg__Sg__Reverse__SWIG_0(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_enumdefinition_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_EnumDefinition_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_enumdefinition_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_EnumDefinition_Sg__Sg__SetRange(arg1,arg2,(std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_vectorptr_enumdefinition(void * jarg1) {
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_constantdefinition_structfield_Clear(void * jarg1) {
  std::vector< RobotRaconteur::ConstantDefinition_StructField > *arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *) 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *)jarg1; 
  
  try {
    (arg1)->clear();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_constantdefinition_structfield_Add(void * jarg1, void * jarg2) {
  std::vector< RobotRaconteur::ConstantDefinition_StructField > *arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *) 0 ;
  RobotRaconteur::ConstantDefinition_StructField *arg2 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *)jarg1; 
  arg2 = (RobotRaconteur::ConstantDefinition_StructField *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::ConstantDefinition_StructField const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->push_back((RobotRaconteur::ConstantDefinition_StructField const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vector_constantdefinition_structfield_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< RobotRaconteur::ConstantDefinition_StructField > *arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *) 0 ;
  std::vector< RobotRaconteur::ConstantDefinition_StructField >::size_type result;
  
  arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *)jarg1; 
  
  try {
    result = ((std::vector< RobotRaconteur::ConstantDefinition_StructField > const *)arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vector_constantdefinition_structfield_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< RobotRaconteur::ConstantDefinition_StructField > *arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *) 0 ;
  std::vector< RobotRaconteur::ConstantDefinition_StructField >::size_type result;
  
  arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *)jarg1; 
  
  try {
    result = ((std::vector< RobotRaconteur::ConstantDefinition_StructField > const *)arg1)->capacity();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_constantdefinition_structfield_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< RobotRaconteur::ConstantDefinition_StructField > *arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *) 0 ;
  std::vector< RobotRaconteur::ConstantDefinition_StructField >::size_type arg2 ;
  
  arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *)jarg1; 
  arg2 = (std::vector< RobotRaconteur::ConstantDefinition_StructField >::size_type)jarg2; 
  
  try {
    (arg1)->reserve(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vector_constantdefinition_structfield__SWIG_0() {
  void * jresult ;
  std::vector< RobotRaconteur::ConstantDefinition_StructField > *result = 0 ;
  
  
  try {
    result = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *)new std::vector< RobotRaconteur::ConstantDefinition_StructField >();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vector_constantdefinition_structfield__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< RobotRaconteur::ConstantDefinition_StructField > *arg1 = 0 ;
  std::vector< RobotRaconteur::ConstantDefinition_StructField > *result = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::ConstantDefinition_StructField > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *)new std::vector< RobotRaconteur::ConstantDefinition_StructField >((std::vector< RobotRaconteur::ConstantDefinition_StructField > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vector_constantdefinition_structfield__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< RobotRaconteur::ConstantDefinition_StructField > *result = 0 ;
  
  arg1 = (int)jarg1; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *)new_std_vector_Sl_RobotRaconteur_ConstantDefinition_StructField_Sg___SWIG_2(arg1);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vector_constantdefinition_structfield_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< RobotRaconteur::ConstantDefinition_StructField > *arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *) 0 ;
  int arg2 ;
  RobotRaconteur::ConstantDefinition_StructField result;
  
  arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = std_vector_Sl_RobotRaconteur_ConstantDefinition_StructField_Sg__getitemcopy(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::ConstantDefinition_StructField((const RobotRaconteur::ConstantDefinition_StructField &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vector_constantdefinition_structfield_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< RobotRaconteur::ConstantDefinition_StructField > *arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *) 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::ConstantDefinition_StructField >::value_type *result = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::ConstantDefinition_StructField >::value_type *) &std_vector_Sl_RobotRaconteur_ConstantDefinition_StructField_Sg__getitem(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_constantdefinition_structfield_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::ConstantDefinition_StructField > *arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *) 0 ;
  int arg2 ;
  RobotRaconteur::ConstantDefinition_StructField *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (RobotRaconteur::ConstantDefinition_StructField *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::ConstantDefinition_StructField const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ConstantDefinition_StructField_Sg__setitem(arg1,arg2,(RobotRaconteur::ConstantDefinition_StructField const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_constantdefinition_structfield_AddRange(void * jarg1, void * jarg2) {
  std::vector< RobotRaconteur::ConstantDefinition_StructField > *arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *) 0 ;
  std::vector< RobotRaconteur::ConstantDefinition_StructField > *arg2 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *)jarg1; 
  arg2 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::ConstantDefinition_StructField > const & type is null", 0);
    return ;
  } 
  
  try {
    std_vector_Sl_RobotRaconteur_ConstantDefinition_StructField_Sg__AddRange(arg1,(std::vector< RobotRaconteur::ConstantDefinition_StructField > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vector_constantdefinition_structfield_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< RobotRaconteur::ConstantDefinition_StructField > *arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< RobotRaconteur::ConstantDefinition_StructField > *result = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *)std_vector_Sl_RobotRaconteur_ConstantDefinition_StructField_Sg__GetRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_constantdefinition_structfield_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::ConstantDefinition_StructField > *arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *) 0 ;
  int arg2 ;
  RobotRaconteur::ConstantDefinition_StructField *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (RobotRaconteur::ConstantDefinition_StructField *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::ConstantDefinition_StructField const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ConstantDefinition_StructField_Sg__Insert(arg1,arg2,(RobotRaconteur::ConstantDefinition_StructField const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_constantdefinition_structfield_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::ConstantDefinition_StructField > *arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *) 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::ConstantDefinition_StructField > *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::ConstantDefinition_StructField > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ConstantDefinition_StructField_Sg__InsertRange(arg1,arg2,(std::vector< RobotRaconteur::ConstantDefinition_StructField > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_constantdefinition_structfield_RemoveAt(void * jarg1, int jarg2) {
  std::vector< RobotRaconteur::ConstantDefinition_StructField > *arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ConstantDefinition_StructField_Sg__RemoveAt(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_constantdefinition_structfield_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< RobotRaconteur::ConstantDefinition_StructField > *arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ConstantDefinition_StructField_Sg__RemoveRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vector_constantdefinition_structfield_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  RobotRaconteur::ConstantDefinition_StructField *arg1 = 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::ConstantDefinition_StructField > *result = 0 ;
  
  arg1 = (RobotRaconteur::ConstantDefinition_StructField *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::ConstantDefinition_StructField const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *)std_vector_Sl_RobotRaconteur_ConstantDefinition_StructField_Sg__Repeat((RobotRaconteur::ConstantDefinition_StructField const &)*arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_constantdefinition_structfield_Reverse__SWIG_0(void * jarg1) {
  std::vector< RobotRaconteur::ConstantDefinition_StructField > *arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *) 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *)jarg1; 
  
  try {
    std_vector_Sl_RobotRaconteur_ConstantDefinition_StructField_Sg__Reverse__SWIG_0(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_constantdefinition_structfield_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< RobotRaconteur::ConstantDefinition_StructField > *arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ConstantDefinition_StructField_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_constantdefinition_structfield_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::ConstantDefinition_StructField > *arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *) 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::ConstantDefinition_StructField > *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::ConstantDefinition_StructField > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ConstantDefinition_StructField_Sg__SetRange(arg1,arg2,(std::vector< RobotRaconteur::ConstantDefinition_StructField > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_vector_constantdefinition_structfield(void * jarg1) {
  std::vector< RobotRaconteur::ConstantDefinition_StructField > *arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *) 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ConstantDefinition_StructField > *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_enumdefinitionvalues_Clear(void * jarg1) {
  std::vector< RobotRaconteur::EnumDefinitionValue > *arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *) 0 ;
  
  arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *)jarg1; 
  
  try {
    (arg1)->clear();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_enumdefinitionvalues_Add(void * jarg1, void * jarg2) {
  std::vector< RobotRaconteur::EnumDefinitionValue > *arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *) 0 ;
  RobotRaconteur::EnumDefinitionValue *arg2 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *)jarg1; 
  arg2 = (RobotRaconteur::EnumDefinitionValue *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::EnumDefinitionValue const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->push_back((RobotRaconteur::EnumDefinitionValue const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vector_enumdefinitionvalues_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< RobotRaconteur::EnumDefinitionValue > *arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *) 0 ;
  std::vector< RobotRaconteur::EnumDefinitionValue >::size_type result;
  
  arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *)jarg1; 
  
  try {
    result = ((std::vector< RobotRaconteur::EnumDefinitionValue > const *)arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vector_enumdefinitionvalues_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< RobotRaconteur::EnumDefinitionValue > *arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *) 0 ;
  std::vector< RobotRaconteur::EnumDefinitionValue >::size_type result;
  
  arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *)jarg1; 
  
  try {
    result = ((std::vector< RobotRaconteur::EnumDefinitionValue > const *)arg1)->capacity();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_enumdefinitionvalues_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< RobotRaconteur::EnumDefinitionValue > *arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *) 0 ;
  std::vector< RobotRaconteur::EnumDefinitionValue >::size_type arg2 ;
  
  arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *)jarg1; 
  arg2 = (std::vector< RobotRaconteur::EnumDefinitionValue >::size_type)jarg2; 
  
  try {
    (arg1)->reserve(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vector_enumdefinitionvalues__SWIG_0() {
  void * jresult ;
  std::vector< RobotRaconteur::EnumDefinitionValue > *result = 0 ;
  
  
  try {
    result = (std::vector< RobotRaconteur::EnumDefinitionValue > *)new std::vector< RobotRaconteur::EnumDefinitionValue >();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vector_enumdefinitionvalues__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< RobotRaconteur::EnumDefinitionValue > *arg1 = 0 ;
  std::vector< RobotRaconteur::EnumDefinitionValue > *result = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::EnumDefinitionValue > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (std::vector< RobotRaconteur::EnumDefinitionValue > *)new std::vector< RobotRaconteur::EnumDefinitionValue >((std::vector< RobotRaconteur::EnumDefinitionValue > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vector_enumdefinitionvalues__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< RobotRaconteur::EnumDefinitionValue > *result = 0 ;
  
  arg1 = (int)jarg1; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::EnumDefinitionValue > *)new_std_vector_Sl_RobotRaconteur_EnumDefinitionValue_Sg___SWIG_2(arg1);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vector_enumdefinitionvalues_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< RobotRaconteur::EnumDefinitionValue > *arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *) 0 ;
  int arg2 ;
  RobotRaconteur::EnumDefinitionValue result;
  
  arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = std_vector_Sl_RobotRaconteur_EnumDefinitionValue_Sg__getitemcopy(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::EnumDefinitionValue((const RobotRaconteur::EnumDefinitionValue &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vector_enumdefinitionvalues_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< RobotRaconteur::EnumDefinitionValue > *arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *) 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::EnumDefinitionValue >::value_type *result = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::EnumDefinitionValue >::value_type *) &std_vector_Sl_RobotRaconteur_EnumDefinitionValue_Sg__getitem(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_enumdefinitionvalues_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::EnumDefinitionValue > *arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *) 0 ;
  int arg2 ;
  RobotRaconteur::EnumDefinitionValue *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (RobotRaconteur::EnumDefinitionValue *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::EnumDefinitionValue const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_EnumDefinitionValue_Sg__setitem(arg1,arg2,(RobotRaconteur::EnumDefinitionValue const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_enumdefinitionvalues_AddRange(void * jarg1, void * jarg2) {
  std::vector< RobotRaconteur::EnumDefinitionValue > *arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *) 0 ;
  std::vector< RobotRaconteur::EnumDefinitionValue > *arg2 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *)jarg1; 
  arg2 = (std::vector< RobotRaconteur::EnumDefinitionValue > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::EnumDefinitionValue > const & type is null", 0);
    return ;
  } 
  
  try {
    std_vector_Sl_RobotRaconteur_EnumDefinitionValue_Sg__AddRange(arg1,(std::vector< RobotRaconteur::EnumDefinitionValue > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vector_enumdefinitionvalues_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< RobotRaconteur::EnumDefinitionValue > *arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< RobotRaconteur::EnumDefinitionValue > *result = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::EnumDefinitionValue > *)std_vector_Sl_RobotRaconteur_EnumDefinitionValue_Sg__GetRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_enumdefinitionvalues_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::EnumDefinitionValue > *arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *) 0 ;
  int arg2 ;
  RobotRaconteur::EnumDefinitionValue *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (RobotRaconteur::EnumDefinitionValue *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::EnumDefinitionValue const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_EnumDefinitionValue_Sg__Insert(arg1,arg2,(RobotRaconteur::EnumDefinitionValue const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_enumdefinitionvalues_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::EnumDefinitionValue > *arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *) 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::EnumDefinitionValue > *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< RobotRaconteur::EnumDefinitionValue > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::EnumDefinitionValue > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_EnumDefinitionValue_Sg__InsertRange(arg1,arg2,(std::vector< RobotRaconteur::EnumDefinitionValue > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_enumdefinitionvalues_RemoveAt(void * jarg1, int jarg2) {
  std::vector< RobotRaconteur::EnumDefinitionValue > *arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_EnumDefinitionValue_Sg__RemoveAt(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_enumdefinitionvalues_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< RobotRaconteur::EnumDefinitionValue > *arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_EnumDefinitionValue_Sg__RemoveRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vector_enumdefinitionvalues_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  RobotRaconteur::EnumDefinitionValue *arg1 = 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::EnumDefinitionValue > *result = 0 ;
  
  arg1 = (RobotRaconteur::EnumDefinitionValue *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::EnumDefinitionValue const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::EnumDefinitionValue > *)std_vector_Sl_RobotRaconteur_EnumDefinitionValue_Sg__Repeat((RobotRaconteur::EnumDefinitionValue const &)*arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_enumdefinitionvalues_Reverse__SWIG_0(void * jarg1) {
  std::vector< RobotRaconteur::EnumDefinitionValue > *arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *) 0 ;
  
  arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *)jarg1; 
  
  try {
    std_vector_Sl_RobotRaconteur_EnumDefinitionValue_Sg__Reverse__SWIG_0(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_enumdefinitionvalues_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< RobotRaconteur::EnumDefinitionValue > *arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_EnumDefinitionValue_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_enumdefinitionvalues_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::EnumDefinitionValue > *arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *) 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::EnumDefinitionValue > *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< RobotRaconteur::EnumDefinitionValue > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::EnumDefinitionValue > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_EnumDefinitionValue_Sg__SetRange(arg1,arg2,(std::vector< RobotRaconteur::EnumDefinitionValue > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_vector_enumdefinitionvalues(void * jarg1) {
  std::vector< RobotRaconteur::EnumDefinitionValue > *arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *) 0 ;
  
  arg1 = (std::vector< RobotRaconteur::EnumDefinitionValue > *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_usingdefinition_Clear(void * jarg1) {
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *)jarg1; 
  
  try {
    (arg1)->clear();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_usingdefinition_Add(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *) 0 ;
  boost::shared_ptr< RobotRaconteur::UsingDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::UsingDefinition > tempnull2 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::UsingDefinition > *)jarg2 : &tempnull2; 
  
  try {
    (arg1)->push_back((boost::shared_ptr< RobotRaconteur::UsingDefinition > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vector_usingdefinition_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *)jarg1; 
  
  try {
    result = ((std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > const *)arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vector_usingdefinition_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *)jarg1; 
  
  try {
    result = ((std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > const *)arg1)->capacity();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_usingdefinition_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > >::size_type arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > >::size_type)jarg2; 
  
  try {
    (arg1)->reserve(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vector_usingdefinition__SWIG_0() {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *result = 0 ;
  
  
  try {
    result = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *)new std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > >();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vector_usingdefinition__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *arg1 = 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *)new std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > >((std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vector_usingdefinition__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *)new_std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_UsingDefinition_Sg__Sg___SWIG_2(arg1);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vector_usingdefinition_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::UsingDefinition > result;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_UsingDefinition_Sg__Sg__getitemcopy(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::UsingDefinition >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vector_usingdefinition_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > >::value_type *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > >::value_type *) &std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_UsingDefinition_Sg__Sg__getitem(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = *result ? new std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > >::value_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_usingdefinition_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::UsingDefinition > *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::UsingDefinition > tempnull3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (boost::shared_ptr< RobotRaconteur::UsingDefinition > *)jarg3 : &tempnull3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_UsingDefinition_Sg__Sg__setitem(arg1,arg2,(boost::shared_ptr< RobotRaconteur::UsingDefinition > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_usingdefinition_AddRange(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > const & type is null", 0);
    return ;
  } 
  
  try {
    std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_UsingDefinition_Sg__Sg__AddRange(arg1,(std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vector_usingdefinition_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *)std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_UsingDefinition_Sg__Sg__GetRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_usingdefinition_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::UsingDefinition > *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::UsingDefinition > tempnull3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (boost::shared_ptr< RobotRaconteur::UsingDefinition > *)jarg3 : &tempnull3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_UsingDefinition_Sg__Sg__Insert(arg1,arg2,(boost::shared_ptr< RobotRaconteur::UsingDefinition > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_usingdefinition_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_UsingDefinition_Sg__Sg__InsertRange(arg1,arg2,(std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_usingdefinition_RemoveAt(void * jarg1, int jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_UsingDefinition_Sg__Sg__RemoveAt(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_usingdefinition_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_UsingDefinition_Sg__Sg__RemoveRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vector_usingdefinition_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::UsingDefinition > *arg1 = 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::UsingDefinition > tempnull1 ;
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::UsingDefinition > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *)std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_UsingDefinition_Sg__Sg__Repeat((boost::shared_ptr< RobotRaconteur::UsingDefinition > const &)*arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_usingdefinition_Reverse__SWIG_0(void * jarg1) {
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *)jarg1; 
  
  try {
    std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_UsingDefinition_Sg__Sg__Reverse__SWIG_0(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_usingdefinition_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_UsingDefinition_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_usingdefinition_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_UsingDefinition_Sg__Sg__SetRange(arg1,arg2,(std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_vector_usingdefinition(void * jarg1) {
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_exceptiondefinition_Clear(void * jarg1) {
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *)jarg1; 
  
  try {
    (arg1)->clear();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_exceptiondefinition_Add(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *) 0 ;
  boost::shared_ptr< RobotRaconteur::ExceptionDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::ExceptionDefinition > tempnull2 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::ExceptionDefinition > *)jarg2 : &tempnull2; 
  
  try {
    (arg1)->push_back((boost::shared_ptr< RobotRaconteur::ExceptionDefinition > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_exceptiondefinition_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *)jarg1; 
  
  try {
    result = ((std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > const *)arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_exceptiondefinition_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *)jarg1; 
  
  try {
    result = ((std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > const *)arg1)->capacity();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_exceptiondefinition_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > >::size_type arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > >::size_type)jarg2; 
  
  try {
    (arg1)->reserve(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_exceptiondefinition__SWIG_0() {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *result = 0 ;
  
  
  try {
    result = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *)new std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > >();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_exceptiondefinition__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *arg1 = 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *)new std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > >((std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_exceptiondefinition__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *)new_std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ExceptionDefinition_Sg__Sg___SWIG_2(arg1);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_exceptiondefinition_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::ExceptionDefinition > result;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ExceptionDefinition_Sg__Sg__getitemcopy(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::ExceptionDefinition >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_exceptiondefinition_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > >::value_type *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > >::value_type *) &std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ExceptionDefinition_Sg__Sg__getitem(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = *result ? new std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > >::value_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_exceptiondefinition_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::ExceptionDefinition > *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::ExceptionDefinition > tempnull3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (boost::shared_ptr< RobotRaconteur::ExceptionDefinition > *)jarg3 : &tempnull3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ExceptionDefinition_Sg__Sg__setitem(arg1,arg2,(boost::shared_ptr< RobotRaconteur::ExceptionDefinition > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_exceptiondefinition_AddRange(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > const & type is null", 0);
    return ;
  } 
  
  try {
    std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ExceptionDefinition_Sg__Sg__AddRange(arg1,(std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_exceptiondefinition_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *)std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ExceptionDefinition_Sg__Sg__GetRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_exceptiondefinition_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::ExceptionDefinition > *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::ExceptionDefinition > tempnull3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (boost::shared_ptr< RobotRaconteur::ExceptionDefinition > *)jarg3 : &tempnull3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ExceptionDefinition_Sg__Sg__Insert(arg1,arg2,(boost::shared_ptr< RobotRaconteur::ExceptionDefinition > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_exceptiondefinition_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ExceptionDefinition_Sg__Sg__InsertRange(arg1,arg2,(std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_exceptiondefinition_RemoveAt(void * jarg1, int jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ExceptionDefinition_Sg__Sg__RemoveAt(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_exceptiondefinition_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ExceptionDefinition_Sg__Sg__RemoveRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_exceptiondefinition_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::ExceptionDefinition > *arg1 = 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::ExceptionDefinition > tempnull1 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::ExceptionDefinition > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *)std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ExceptionDefinition_Sg__Sg__Repeat((boost::shared_ptr< RobotRaconteur::ExceptionDefinition > const &)*arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_exceptiondefinition_Reverse__SWIG_0(void * jarg1) {
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *)jarg1; 
  
  try {
    std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ExceptionDefinition_Sg__Sg__Reverse__SWIG_0(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_exceptiondefinition_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ExceptionDefinition_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_exceptiondefinition_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ExceptionDefinition_Sg__Sg__SetRange(arg1,arg2,(std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_vectorptr_exceptiondefinition(void * jarg1) {
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_servicedefinition_Clear(void * jarg1) {
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *)jarg1; 
  
  try {
    (arg1)->clear();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_servicedefinition_Add(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > tempnull2 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::ServiceDefinition > *)jarg2 : &tempnull2; 
  
  try {
    (arg1)->push_back((boost::shared_ptr< RobotRaconteur::ServiceDefinition > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_servicedefinition_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *)jarg1; 
  
  try {
    result = ((std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > const *)arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_servicedefinition_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *)jarg1; 
  
  try {
    result = ((std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > const *)arg1)->capacity();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_servicedefinition_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > >::size_type arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > >::size_type)jarg2; 
  
  try {
    (arg1)->reserve(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_servicedefinition__SWIG_0() {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *result = 0 ;
  
  
  try {
    result = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *)new std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > >();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_servicedefinition__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *arg1 = 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *)new std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > >((std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_servicedefinition__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *)new_std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceDefinition_Sg__Sg___SWIG_2(arg1);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_servicedefinition_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > result;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceDefinition_Sg__Sg__getitemcopy(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::ServiceDefinition >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_servicedefinition_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > >::value_type *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > >::value_type *) &std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceDefinition_Sg__Sg__getitem(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = *result ? new std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > >::value_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_servicedefinition_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > tempnull3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (boost::shared_ptr< RobotRaconteur::ServiceDefinition > *)jarg3 : &tempnull3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceDefinition_Sg__Sg__setitem(arg1,arg2,(boost::shared_ptr< RobotRaconteur::ServiceDefinition > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_servicedefinition_AddRange(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > const & type is null", 0);
    return ;
  } 
  
  try {
    std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceDefinition_Sg__Sg__AddRange(arg1,(std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_servicedefinition_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *)std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceDefinition_Sg__Sg__GetRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_servicedefinition_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > tempnull3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (boost::shared_ptr< RobotRaconteur::ServiceDefinition > *)jarg3 : &tempnull3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceDefinition_Sg__Sg__Insert(arg1,arg2,(boost::shared_ptr< RobotRaconteur::ServiceDefinition > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_servicedefinition_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceDefinition_Sg__Sg__InsertRange(arg1,arg2,(std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_servicedefinition_RemoveAt(void * jarg1, int jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceDefinition_Sg__Sg__RemoveAt(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_servicedefinition_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceDefinition_Sg__Sg__RemoveRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_servicedefinition_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *arg1 = 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > tempnull1 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::ServiceDefinition > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *)std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceDefinition_Sg__Sg__Repeat((boost::shared_ptr< RobotRaconteur::ServiceDefinition > const &)*arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_servicedefinition_Reverse__SWIG_0(void * jarg1) {
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *)jarg1; 
  
  try {
    std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceDefinition_Sg__Sg__Reverse__SWIG_0(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_servicedefinition_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceDefinition_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_servicedefinition_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_ServiceDefinition_Sg__Sg__SetRange(arg1,arg2,(std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_vectorptr_servicedefinition(void * jarg1) {
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinitionParseInfo_ServiceName_set(void * jarg1, char * jarg2) {
  RobotRaconteur::ServiceDefinitionParseInfo *arg1 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->ServiceName = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinitionParseInfo_ServiceName_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::ServiceDefinitionParseInfo *arg1 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg1; 
  result = (std::string *) & ((arg1)->ServiceName);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinitionParseInfo_RobDefFilePath_set(void * jarg1, char * jarg2) {
  RobotRaconteur::ServiceDefinitionParseInfo *arg1 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->RobDefFilePath = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinitionParseInfo_RobDefFilePath_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::ServiceDefinitionParseInfo *arg1 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg1; 
  result = (std::string *) & ((arg1)->RobDefFilePath);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinitionParseInfo_Line_set(void * jarg1, char * jarg2) {
  RobotRaconteur::ServiceDefinitionParseInfo *arg1 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->Line = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinitionParseInfo_Line_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::ServiceDefinitionParseInfo *arg1 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg1; 
  result = (std::string *) & ((arg1)->Line);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinitionParseInfo_LineNumber_set(void * jarg1, int jarg2) {
  RobotRaconteur::ServiceDefinitionParseInfo *arg1 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  int32_t arg2 ;
  
  arg1 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg1; 
  arg2 = (int32_t)jarg2; 
  if (arg1) (arg1)->LineNumber = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinitionParseInfo_LineNumber_get(void * jarg1) {
  int jresult ;
  RobotRaconteur::ServiceDefinitionParseInfo *arg1 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  int32_t result;
  
  arg1 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg1; 
  result = (int32_t) ((arg1)->LineNumber);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_ServiceDefinitionParseInfo() {
  void * jresult ;
  RobotRaconteur::ServiceDefinitionParseInfo *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::ServiceDefinitionParseInfo *)new RobotRaconteur::ServiceDefinitionParseInfo();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinitionParseInfo_Reset(void * jarg1) {
  RobotRaconteur::ServiceDefinitionParseInfo *arg1 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  
  arg1 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg1; 
  
  try {
    (arg1)->Reset();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_ServiceDefinitionParseInfo(void * jarg1) {
  RobotRaconteur::ServiceDefinitionParseInfo *arg1 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  
  arg1 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_RobotRaconteurVersion__SWIG_0() {
  void * jresult ;
  RobotRaconteur::RobotRaconteurVersion *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::RobotRaconteurVersion *)new RobotRaconteur::RobotRaconteurVersion();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_RobotRaconteurVersion__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
  void * jresult ;
  uint32_t arg1 ;
  uint32_t arg2 ;
  uint32_t arg3 ;
  uint32_t arg4 ;
  RobotRaconteur::RobotRaconteurVersion *result = 0 ;
  
  arg1 = (uint32_t)jarg1; 
  arg2 = (uint32_t)jarg2; 
  arg3 = (uint32_t)jarg3; 
  arg4 = (uint32_t)jarg4; 
  
  try {
    result = (RobotRaconteur::RobotRaconteurVersion *)new RobotRaconteur::RobotRaconteurVersion(arg1,arg2,arg3,arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_RobotRaconteurVersion__SWIG_2(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
  void * jresult ;
  uint32_t arg1 ;
  uint32_t arg2 ;
  uint32_t arg3 ;
  RobotRaconteur::RobotRaconteurVersion *result = 0 ;
  
  arg1 = (uint32_t)jarg1; 
  arg2 = (uint32_t)jarg2; 
  arg3 = (uint32_t)jarg3; 
  
  try {
    result = (RobotRaconteur::RobotRaconteurVersion *)new RobotRaconteur::RobotRaconteurVersion(arg1,arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_RobotRaconteurVersion__SWIG_3(unsigned int jarg1, unsigned int jarg2) {
  void * jresult ;
  uint32_t arg1 ;
  uint32_t arg2 ;
  RobotRaconteur::RobotRaconteurVersion *result = 0 ;
  
  arg1 = (uint32_t)jarg1; 
  arg2 = (uint32_t)jarg2; 
  
  try {
    result = (RobotRaconteur::RobotRaconteurVersion *)new RobotRaconteur::RobotRaconteurVersion(arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_RobotRaconteurVersion__SWIG_4(char * jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  RobotRaconteur::RobotRaconteurVersion *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  
  try {
    result = (RobotRaconteur::RobotRaconteurVersion *)new RobotRaconteur::RobotRaconteurVersion((std::string const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurVersion_ToString(void * jarg1) {
  char * jresult ;
  RobotRaconteur::RobotRaconteurVersion *arg1 = (RobotRaconteur::RobotRaconteurVersion *) 0 ;
  std::string result;
  
  arg1 = (RobotRaconteur::RobotRaconteurVersion *)jarg1; 
  
  try {
    result = ((RobotRaconteur::RobotRaconteurVersion const *)arg1)->ToString();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurVersion_FromString__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
  RobotRaconteur::RobotRaconteurVersion *arg1 = (RobotRaconteur::RobotRaconteurVersion *) 0 ;
  std::string *arg2 = 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  
  arg1 = (RobotRaconteur::RobotRaconteurVersion *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg3; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2,(RobotRaconteur::ServiceDefinitionParseInfo const *)arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurVersion_FromString__SWIG_1(void * jarg1, char * jarg2) {
  RobotRaconteur::RobotRaconteurVersion *arg1 = (RobotRaconteur::RobotRaconteurVersion *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::RobotRaconteurVersion *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurVersion_major_set(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::RobotRaconteurVersion *arg1 = (RobotRaconteur::RobotRaconteurVersion *) 0 ;
  uint32_t arg2 ;
  
  arg1 = (RobotRaconteur::RobotRaconteurVersion *)jarg1; 
  arg2 = (uint32_t)jarg2; 
  if (arg1) (arg1)->major = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurVersion_major_get(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::RobotRaconteurVersion *arg1 = (RobotRaconteur::RobotRaconteurVersion *) 0 ;
  uint32_t result;
  
  arg1 = (RobotRaconteur::RobotRaconteurVersion *)jarg1; 
  result = (uint32_t) ((arg1)->major);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurVersion_minor_set(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::RobotRaconteurVersion *arg1 = (RobotRaconteur::RobotRaconteurVersion *) 0 ;
  uint32_t arg2 ;
  
  arg1 = (RobotRaconteur::RobotRaconteurVersion *)jarg1; 
  arg2 = (uint32_t)jarg2; 
  if (arg1) (arg1)->minor = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurVersion_minor_get(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::RobotRaconteurVersion *arg1 = (RobotRaconteur::RobotRaconteurVersion *) 0 ;
  uint32_t result;
  
  arg1 = (RobotRaconteur::RobotRaconteurVersion *)jarg1; 
  result = (uint32_t) ((arg1)->minor);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurVersion_patch_set(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::RobotRaconteurVersion *arg1 = (RobotRaconteur::RobotRaconteurVersion *) 0 ;
  uint32_t arg2 ;
  
  arg1 = (RobotRaconteur::RobotRaconteurVersion *)jarg1; 
  arg2 = (uint32_t)jarg2; 
  if (arg1) (arg1)->patch = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurVersion_patch_get(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::RobotRaconteurVersion *arg1 = (RobotRaconteur::RobotRaconteurVersion *) 0 ;
  uint32_t result;
  
  arg1 = (RobotRaconteur::RobotRaconteurVersion *)jarg1; 
  result = (uint32_t) ((arg1)->patch);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurVersion_tweak_set(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::RobotRaconteurVersion *arg1 = (RobotRaconteur::RobotRaconteurVersion *) 0 ;
  uint32_t arg2 ;
  
  arg1 = (RobotRaconteur::RobotRaconteurVersion *)jarg1; 
  arg2 = (uint32_t)jarg2; 
  if (arg1) (arg1)->tweak = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurVersion_tweak_get(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::RobotRaconteurVersion *arg1 = (RobotRaconteur::RobotRaconteurVersion *) 0 ;
  uint32_t result;
  
  arg1 = (RobotRaconteur::RobotRaconteurVersion *)jarg1; 
  result = (uint32_t) ((arg1)->tweak);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurVersion_ParseInfo_set(void * jarg1, void * jarg2) {
  RobotRaconteur::RobotRaconteurVersion *arg1 = (RobotRaconteur::RobotRaconteurVersion *) 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *arg2 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  
  arg1 = (RobotRaconteur::RobotRaconteurVersion *)jarg1; 
  arg2 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg2; 
  if (arg1) (arg1)->ParseInfo = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurVersion_ParseInfo_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurVersion *arg1 = (RobotRaconteur::RobotRaconteurVersion *) 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *result = 0 ;
  
  arg1 = (RobotRaconteur::RobotRaconteurVersion *)jarg1; 
  result = (RobotRaconteur::ServiceDefinitionParseInfo *)& ((arg1)->ParseInfo);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_RobotRaconteurVersion(void * jarg1) {
  RobotRaconteur::RobotRaconteurVersion *arg1 = (RobotRaconteur::RobotRaconteurVersion *) 0 ;
  
  arg1 = (RobotRaconteur::RobotRaconteurVersion *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurVersion_eq(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::RobotRaconteurVersion *arg1 = 0 ;
  RobotRaconteur::RobotRaconteurVersion *arg2 = 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::RobotRaconteurVersion *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::RobotRaconteurVersion const & type is null", 0);
    return 0;
  } 
  arg2 = (RobotRaconteur::RobotRaconteurVersion *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::RobotRaconteurVersion const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)operator ==((RobotRaconteur::RobotRaconteurVersion const &)*arg1,(RobotRaconteur::RobotRaconteurVersion const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurVersion_ne(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::RobotRaconteurVersion *arg1 = 0 ;
  RobotRaconteur::RobotRaconteurVersion *arg2 = 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::RobotRaconteurVersion *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::RobotRaconteurVersion const & type is null", 0);
    return 0;
  } 
  arg2 = (RobotRaconteur::RobotRaconteurVersion *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::RobotRaconteurVersion const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)operator !=((RobotRaconteur::RobotRaconteurVersion const &)*arg1,(RobotRaconteur::RobotRaconteurVersion const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurVersion_gt(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::RobotRaconteurVersion *arg1 = 0 ;
  RobotRaconteur::RobotRaconteurVersion *arg2 = 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::RobotRaconteurVersion *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::RobotRaconteurVersion const & type is null", 0);
    return 0;
  } 
  arg2 = (RobotRaconteur::RobotRaconteurVersion *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::RobotRaconteurVersion const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)operator >((RobotRaconteur::RobotRaconteurVersion const &)*arg1,(RobotRaconteur::RobotRaconteurVersion const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurVersion_ge(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::RobotRaconteurVersion *arg1 = 0 ;
  RobotRaconteur::RobotRaconteurVersion *arg2 = 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::RobotRaconteurVersion *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::RobotRaconteurVersion const & type is null", 0);
    return 0;
  } 
  arg2 = (RobotRaconteur::RobotRaconteurVersion *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::RobotRaconteurVersion const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)operator >=((RobotRaconteur::RobotRaconteurVersion const &)*arg1,(RobotRaconteur::RobotRaconteurVersion const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurVersion_lt(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::RobotRaconteurVersion *arg1 = 0 ;
  RobotRaconteur::RobotRaconteurVersion *arg2 = 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::RobotRaconteurVersion *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::RobotRaconteurVersion const & type is null", 0);
    return 0;
  } 
  arg2 = (RobotRaconteur::RobotRaconteurVersion *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::RobotRaconteurVersion const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)operator <((RobotRaconteur::RobotRaconteurVersion const &)*arg1,(RobotRaconteur::RobotRaconteurVersion const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurVersion_le(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::RobotRaconteurVersion *arg1 = 0 ;
  RobotRaconteur::RobotRaconteurVersion *arg2 = 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::RobotRaconteurVersion *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::RobotRaconteurVersion const & type is null", 0);
    return 0;
  } 
  arg2 = (RobotRaconteur::RobotRaconteurVersion *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::RobotRaconteurVersion const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)operator <=((RobotRaconteur::RobotRaconteurVersion const &)*arg1,(RobotRaconteur::RobotRaconteurVersion const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_Name_set(void * jarg1, char * jarg2) {
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->Name = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_Name_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  std::string *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::string *) & ((arg1)->Name);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_NamedArrays_set(void * jarg1, void * jarg2) {
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)jarg2; 
  if (arg1) (arg1)->NamedArrays = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_NamedArrays_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)& ((arg1)->NamedArrays);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_Pods_set(void * jarg1, void * jarg2) {
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)jarg2; 
  if (arg1) (arg1)->Pods = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_Pods_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)& ((arg1)->Pods);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_Structures_set(void * jarg1, void * jarg2) {
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)jarg2; 
  if (arg1) (arg1)->Structures = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_Structures_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)& ((arg1)->Structures);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_Objects_set(void * jarg1, void * jarg2) {
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)jarg2; 
  if (arg1) (arg1)->Objects = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_Objects_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > > *)& ((arg1)->Objects);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_Options_set(void * jarg1, void * jarg2) {
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  std::vector< std::string > *arg2 = (std::vector< std::string > *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< std::string > *)jarg2; 
  if (arg1) (arg1)->Options = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_Options_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  std::vector< std::string > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::vector< std::string > *)& ((arg1)->Options);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_Imports_set(void * jarg1, void * jarg2) {
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  std::vector< std::string > *arg2 = (std::vector< std::string > *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< std::string > *)jarg2; 
  if (arg1) (arg1)->Imports = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_Imports_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  std::vector< std::string > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::vector< std::string > *)& ((arg1)->Imports);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_Exceptions_set(void * jarg1, void * jarg2) {
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *)jarg2; 
  if (arg1) (arg1)->Exceptions = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_Exceptions_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::vector< boost::shared_ptr< RobotRaconteur::ExceptionDefinition > > *)& ((arg1)->Exceptions);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_Using_set(void * jarg1, void * jarg2) {
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *)jarg2; 
  if (arg1) (arg1)->Using = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_Using_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::vector< boost::shared_ptr< RobotRaconteur::UsingDefinition > > *)& ((arg1)->Using);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_Constants_set(void * jarg1, void * jarg2) {
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)jarg2; 
  if (arg1) (arg1)->Constants = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_Constants_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)& ((arg1)->Constants);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_Enums_set(void * jarg1, void * jarg2) {
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *)jarg2; 
  if (arg1) (arg1)->Enums = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_Enums_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::vector< boost::shared_ptr< RobotRaconteur::EnumDefinition > > *)& ((arg1)->Enums);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_StdVer_set(void * jarg1, void * jarg2) {
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  RobotRaconteur::RobotRaconteurVersion *arg2 = (RobotRaconteur::RobotRaconteurVersion *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::RobotRaconteurVersion *)jarg2; 
  if (arg1) (arg1)->StdVer = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_StdVer_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  RobotRaconteur::RobotRaconteurVersion *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (RobotRaconteur::RobotRaconteurVersion *)& ((arg1)->StdVer);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_ParseInfo_set(void * jarg1, void * jarg2) {
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *arg2 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg2; 
  if (arg1) (arg1)->ParseInfo = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_ParseInfo_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (RobotRaconteur::ServiceDefinitionParseInfo *)& ((arg1)->ParseInfo);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_DocString_set(void * jarg1, char * jarg2) {
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->DocString = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_DocString_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  std::string *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::string *) & ((arg1)->DocString);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_ToString(void * jarg1) {
  char * jresult ;
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->ToString();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_FromString__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  std::string *arg2 = 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg3; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2,(RobotRaconteur::ServiceDefinitionParseInfo const *)arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_FromString__SWIG_1(void * jarg1, char * jarg2) {
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_ServiceDefinition() {
  void * jresult ;
  RobotRaconteur::ServiceDefinition *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::ServiceDefinition *)new RobotRaconteur::ServiceDefinition();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::ServiceDefinition >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceDefinition_Reset(void * jarg1) {
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->Reset();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_ServiceDefinition(void * jarg1) {
  RobotRaconteur::ServiceDefinition *arg1 = (RobotRaconteur::ServiceDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceEntryDefinition_Name_set(void * jarg1, char * jarg2) {
  RobotRaconteur::ServiceEntryDefinition *arg1 = (RobotRaconteur::ServiceEntryDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceEntryDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceEntryDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->Name = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ServiceEntryDefinition_Name_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::ServiceEntryDefinition *arg1 = (RobotRaconteur::ServiceEntryDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *smartarg1 = 0 ;
  std::string *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceEntryDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceEntryDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::string *) & ((arg1)->Name);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceEntryDefinition_Members_set(void * jarg1, void * jarg2) {
  RobotRaconteur::ServiceEntryDefinition *arg1 = (RobotRaconteur::ServiceEntryDefinition *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceEntryDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceEntryDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *)jarg2; 
  if (arg1) (arg1)->Members = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServiceEntryDefinition_Members_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ServiceEntryDefinition *arg1 = (RobotRaconteur::ServiceEntryDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *smartarg1 = 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceEntryDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceEntryDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::vector< boost::shared_ptr< RobotRaconteur::MemberDefinition > > *)& ((arg1)->Members);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceEntryDefinition_EntryType_set(void * jarg1, int jarg2) {
  RobotRaconteur::ServiceEntryDefinition *arg1 = (RobotRaconteur::ServiceEntryDefinition *) 0 ;
  RobotRaconteur::DataTypes arg2 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceEntryDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceEntryDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::DataTypes)jarg2; 
  if (arg1) (arg1)->EntryType = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_ServiceEntryDefinition_EntryType_get(void * jarg1) {
  int jresult ;
  RobotRaconteur::ServiceEntryDefinition *arg1 = (RobotRaconteur::ServiceEntryDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *smartarg1 = 0 ;
  RobotRaconteur::DataTypes result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceEntryDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceEntryDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (RobotRaconteur::DataTypes) ((arg1)->EntryType);
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceEntryDefinition_Implements_set(void * jarg1, void * jarg2) {
  RobotRaconteur::ServiceEntryDefinition *arg1 = (RobotRaconteur::ServiceEntryDefinition *) 0 ;
  std::vector< std::string > *arg2 = (std::vector< std::string > *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceEntryDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceEntryDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< std::string > *)jarg2; 
  if (arg1) (arg1)->Implements = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServiceEntryDefinition_Implements_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ServiceEntryDefinition *arg1 = (RobotRaconteur::ServiceEntryDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *smartarg1 = 0 ;
  std::vector< std::string > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceEntryDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceEntryDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::vector< std::string > *)& ((arg1)->Implements);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceEntryDefinition_Options_set(void * jarg1, void * jarg2) {
  RobotRaconteur::ServiceEntryDefinition *arg1 = (RobotRaconteur::ServiceEntryDefinition *) 0 ;
  std::vector< std::string > *arg2 = (std::vector< std::string > *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceEntryDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceEntryDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< std::string > *)jarg2; 
  if (arg1) (arg1)->Options = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServiceEntryDefinition_Options_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ServiceEntryDefinition *arg1 = (RobotRaconteur::ServiceEntryDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *smartarg1 = 0 ;
  std::vector< std::string > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceEntryDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceEntryDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::vector< std::string > *)& ((arg1)->Options);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceEntryDefinition_Constants_set(void * jarg1, void * jarg2) {
  RobotRaconteur::ServiceEntryDefinition *arg1 = (RobotRaconteur::ServiceEntryDefinition *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceEntryDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceEntryDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)jarg2; 
  if (arg1) (arg1)->Constants = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServiceEntryDefinition_Constants_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ServiceEntryDefinition *arg1 = (RobotRaconteur::ServiceEntryDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *smartarg1 = 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceEntryDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceEntryDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::vector< boost::shared_ptr< RobotRaconteur::ConstantDefinition > > *)& ((arg1)->Constants);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceEntryDefinition_ParseInfo_set(void * jarg1, void * jarg2) {
  RobotRaconteur::ServiceEntryDefinition *arg1 = (RobotRaconteur::ServiceEntryDefinition *) 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *arg2 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceEntryDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceEntryDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg2; 
  if (arg1) (arg1)->ParseInfo = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServiceEntryDefinition_ParseInfo_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ServiceEntryDefinition *arg1 = (RobotRaconteur::ServiceEntryDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *smartarg1 = 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceEntryDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceEntryDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (RobotRaconteur::ServiceDefinitionParseInfo *)& ((arg1)->ParseInfo);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceEntryDefinition_DocString_set(void * jarg1, char * jarg2) {
  RobotRaconteur::ServiceEntryDefinition *arg1 = (RobotRaconteur::ServiceEntryDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceEntryDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceEntryDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->DocString = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ServiceEntryDefinition_DocString_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::ServiceEntryDefinition *arg1 = (RobotRaconteur::ServiceEntryDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *smartarg1 = 0 ;
  std::string *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceEntryDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceEntryDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::string *) & ((arg1)->DocString);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_ServiceEntryDefinition(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > tempnull1 ;
  RobotRaconteur::ServiceEntryDefinition *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::ServiceDefinition > *)jarg1 : &tempnull1; 
  
  try {
    result = (RobotRaconteur::ServiceEntryDefinition *)new RobotRaconteur::ServiceEntryDefinition((boost::shared_ptr< RobotRaconteur::ServiceDefinition > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::ServiceEntryDefinition >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ServiceEntryDefinition_ToString(void * jarg1) {
  char * jresult ;
  RobotRaconteur::ServiceEntryDefinition *arg1 = (RobotRaconteur::ServiceEntryDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceEntryDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceEntryDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->ToString();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceEntryDefinition_FromString__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
  RobotRaconteur::ServiceEntryDefinition *arg1 = (RobotRaconteur::ServiceEntryDefinition *) 0 ;
  std::string *arg2 = 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceEntryDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceEntryDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg3; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2,(RobotRaconteur::ServiceDefinitionParseInfo const *)arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceEntryDefinition_FromString__SWIG_1(void * jarg1, char * jarg2) {
  RobotRaconteur::ServiceEntryDefinition *arg1 = (RobotRaconteur::ServiceEntryDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceEntryDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceEntryDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServiceEntryDefinition_GetServiceDefinition(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ServiceEntryDefinition *arg1 = (RobotRaconteur::ServiceEntryDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceEntryDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceEntryDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = RobotRaconteur_ServiceEntryDefinition_GetServiceDefinition(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::ServiceDefinition >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceEntryDefinition_SetServiceDefinition(void * jarg1, void * jarg2) {
  RobotRaconteur::ServiceEntryDefinition *arg1 = (RobotRaconteur::ServiceEntryDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceEntryDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceEntryDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::ServiceDefinition > *)jarg2 : &tempnull2; 
  
  try {
    RobotRaconteur_ServiceEntryDefinition_SetServiceDefinition(arg1,(boost::shared_ptr< RobotRaconteur::ServiceDefinition > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceEntryDefinition_Reset(void * jarg1) {
  RobotRaconteur::ServiceEntryDefinition *arg1 = (RobotRaconteur::ServiceEntryDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceEntryDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceEntryDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->Reset();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_ServiceEntryDefinition(void * jarg1) {
  RobotRaconteur::ServiceEntryDefinition *arg1 = (RobotRaconteur::ServiceEntryDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceEntryDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ServiceEntryDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MemberDefinition_Name_set(void * jarg1, char * jarg2) {
  RobotRaconteur::MemberDefinition *arg1 = (RobotRaconteur::MemberDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::MemberDefinition > *)jarg1;
  arg1 = (RobotRaconteur::MemberDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->Name = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_MemberDefinition_Name_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::MemberDefinition *arg1 = (RobotRaconteur::MemberDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > *smartarg1 = 0 ;
  std::string *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::MemberDefinition > *)jarg1;
  arg1 = (RobotRaconteur::MemberDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::string *) & ((arg1)->Name);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MemberDefinition_DocString_set(void * jarg1, char * jarg2) {
  RobotRaconteur::MemberDefinition *arg1 = (RobotRaconteur::MemberDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::MemberDefinition > *)jarg1;
  arg1 = (RobotRaconteur::MemberDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->DocString = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_MemberDefinition_DocString_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::MemberDefinition *arg1 = (RobotRaconteur::MemberDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > *smartarg1 = 0 ;
  std::string *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::MemberDefinition > *)jarg1;
  arg1 = (RobotRaconteur::MemberDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::string *) & ((arg1)->DocString);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_MemberDefinition(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > tempnull1 ;
  RobotRaconteur::MemberDefinition *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *)jarg1 : &tempnull1; 
  
  try {
    result = (RobotRaconteur::MemberDefinition *)new RobotRaconteur::MemberDefinition((boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::MemberDefinition >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_MemberDefinition_NoLock(void * jarg1) {
  int jresult ;
  RobotRaconteur::MemberDefinition *arg1 = (RobotRaconteur::MemberDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > *smartarg1 = 0 ;
  RobotRaconteur::MemberDefinition_NoLock result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::MemberDefinition > *)jarg1;
  arg1 = (RobotRaconteur::MemberDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (RobotRaconteur::MemberDefinition_NoLock)(arg1)->NoLock();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_MemberDefinition_ToString(void * jarg1) {
  char * jresult ;
  RobotRaconteur::MemberDefinition *arg1 = (RobotRaconteur::MemberDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::MemberDefinition > *)jarg1;
  arg1 = (RobotRaconteur::MemberDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->ToString();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MemberDefinition_GetServiceEntry(void * jarg1) {
  void * jresult ;
  RobotRaconteur::MemberDefinition *arg1 = (RobotRaconteur::MemberDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::MemberDefinition > *)jarg1;
  arg1 = (RobotRaconteur::MemberDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = RobotRaconteur_MemberDefinition_GetServiceEntry(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MemberDefinition_SetServiceEntry(void * jarg1, void * jarg2) {
  RobotRaconteur::MemberDefinition *arg1 = (RobotRaconteur::MemberDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::MemberDefinition > *)jarg1;
  arg1 = (RobotRaconteur::MemberDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *)jarg2 : &tempnull2; 
  
  try {
    RobotRaconteur_MemberDefinition_SetServiceEntry(arg1,(boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MemberDefinition_Modifiers_set(void * jarg1, void * jarg2) {
  RobotRaconteur::MemberDefinition *arg1 = (RobotRaconteur::MemberDefinition *) 0 ;
  std::vector< std::string > *arg2 = (std::vector< std::string > *) 0 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::MemberDefinition > *)jarg1;
  arg1 = (RobotRaconteur::MemberDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< std::string > *)jarg2; 
  if (arg1) (arg1)->Modifiers = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MemberDefinition_Modifiers_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::MemberDefinition *arg1 = (RobotRaconteur::MemberDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > *smartarg1 = 0 ;
  std::vector< std::string > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::MemberDefinition > *)jarg1;
  arg1 = (RobotRaconteur::MemberDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::vector< std::string > *)& ((arg1)->Modifiers);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MemberDefinition_ParseInfo_set(void * jarg1, void * jarg2) {
  RobotRaconteur::MemberDefinition *arg1 = (RobotRaconteur::MemberDefinition *) 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *arg2 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::MemberDefinition > *)jarg1;
  arg1 = (RobotRaconteur::MemberDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg2; 
  if (arg1) (arg1)->ParseInfo = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MemberDefinition_ParseInfo_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::MemberDefinition *arg1 = (RobotRaconteur::MemberDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > *smartarg1 = 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::MemberDefinition > *)jarg1;
  arg1 = (RobotRaconteur::MemberDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (RobotRaconteur::ServiceDefinitionParseInfo *)& ((arg1)->ParseInfo);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MemberDefinition_Reset(void * jarg1) {
  RobotRaconteur::MemberDefinition *arg1 = (RobotRaconteur::MemberDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::MemberDefinition > *)jarg1;
  arg1 = (RobotRaconteur::MemberDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->Reset();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_MemberDefinition(void * jarg1) {
  RobotRaconteur::MemberDefinition *arg1 = (RobotRaconteur::MemberDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::MemberDefinition > *)jarg1;
  arg1 = (RobotRaconteur::MemberDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_PropertyDefinition_Type_set(void * jarg1, void * jarg2) {
  RobotRaconteur::PropertyDefinition *arg1 = (RobotRaconteur::PropertyDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::PropertyDefinition > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::PropertyDefinition > *)jarg1;
  arg1 = (RobotRaconteur::PropertyDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::TypeDefinition > *)jarg2 : &tempnull2; 
  if (arg1) (arg1)->Type = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_PropertyDefinition_Type_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::PropertyDefinition *arg1 = (RobotRaconteur::PropertyDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::PropertyDefinition > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::PropertyDefinition > *)jarg1;
  arg1 = (RobotRaconteur::PropertyDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (boost::shared_ptr< RobotRaconteur::TypeDefinition > *) & ((arg1)->Type);
  jresult = *result ? new boost::shared_ptr< RobotRaconteur::TypeDefinition >(*result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_PropertyDefinition(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > tempnull1 ;
  RobotRaconteur::PropertyDefinition *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *)jarg1 : &tempnull1; 
  
  try {
    result = (RobotRaconteur::PropertyDefinition *)new RobotRaconteur::PropertyDefinition((boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::PropertyDefinition >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_PropertyDefinition_ToString__SWIG_0(void * jarg1) {
  char * jresult ;
  RobotRaconteur::PropertyDefinition *arg1 = (RobotRaconteur::PropertyDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::PropertyDefinition > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::PropertyDefinition > *)jarg1;
  arg1 = (RobotRaconteur::PropertyDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->ToString();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_PropertyDefinition_ToString__SWIG_1(void * jarg1, unsigned int jarg2) {
  char * jresult ;
  RobotRaconteur::PropertyDefinition *arg1 = (RobotRaconteur::PropertyDefinition *) 0 ;
  bool arg2 ;
  boost::shared_ptr< RobotRaconteur::PropertyDefinition > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::PropertyDefinition > *)jarg1;
  arg1 = (RobotRaconteur::PropertyDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? true : false; 
  
  try {
    result = (arg1)->ToString(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_PropertyDefinition_FromString__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
  RobotRaconteur::PropertyDefinition *arg1 = (RobotRaconteur::PropertyDefinition *) 0 ;
  std::string *arg2 = 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  boost::shared_ptr< RobotRaconteur::PropertyDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::PropertyDefinition > *)jarg1;
  arg1 = (RobotRaconteur::PropertyDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg3; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2,(RobotRaconteur::ServiceDefinitionParseInfo const *)arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_PropertyDefinition_FromString__SWIG_1(void * jarg1, char * jarg2) {
  RobotRaconteur::PropertyDefinition *arg1 = (RobotRaconteur::PropertyDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::PropertyDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::PropertyDefinition > *)jarg1;
  arg1 = (RobotRaconteur::PropertyDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_PropertyDefinition(void * jarg1) {
  RobotRaconteur::PropertyDefinition *arg1 = (RobotRaconteur::PropertyDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::PropertyDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::PropertyDefinition > *)jarg1;
  arg1 = (RobotRaconteur::PropertyDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_FunctionDefinition_ReturnType_set(void * jarg1, void * jarg2) {
  RobotRaconteur::FunctionDefinition *arg1 = (RobotRaconteur::FunctionDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::FunctionDefinition > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::FunctionDefinition > *)jarg1;
  arg1 = (RobotRaconteur::FunctionDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::TypeDefinition > *)jarg2 : &tempnull2; 
  if (arg1) (arg1)->ReturnType = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_FunctionDefinition_ReturnType_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::FunctionDefinition *arg1 = (RobotRaconteur::FunctionDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::FunctionDefinition > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::FunctionDefinition > *)jarg1;
  arg1 = (RobotRaconteur::FunctionDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (boost::shared_ptr< RobotRaconteur::TypeDefinition > *) & ((arg1)->ReturnType);
  jresult = *result ? new boost::shared_ptr< RobotRaconteur::TypeDefinition >(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_FunctionDefinition_Parameters_set(void * jarg1, void * jarg2) {
  RobotRaconteur::FunctionDefinition *arg1 = (RobotRaconteur::FunctionDefinition *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *) 0 ;
  boost::shared_ptr< RobotRaconteur::FunctionDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::FunctionDefinition > *)jarg1;
  arg1 = (RobotRaconteur::FunctionDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)jarg2; 
  if (arg1) (arg1)->Parameters = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_FunctionDefinition_Parameters_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::FunctionDefinition *arg1 = (RobotRaconteur::FunctionDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::FunctionDefinition > *smartarg1 = 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::FunctionDefinition > *)jarg1;
  arg1 = (RobotRaconteur::FunctionDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)& ((arg1)->Parameters);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_FunctionDefinition(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > tempnull1 ;
  RobotRaconteur::FunctionDefinition *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *)jarg1 : &tempnull1; 
  
  try {
    result = (RobotRaconteur::FunctionDefinition *)new RobotRaconteur::FunctionDefinition((boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::FunctionDefinition >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_FunctionDefinition_ToString(void * jarg1) {
  char * jresult ;
  RobotRaconteur::FunctionDefinition *arg1 = (RobotRaconteur::FunctionDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::FunctionDefinition > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::FunctionDefinition > *)jarg1;
  arg1 = (RobotRaconteur::FunctionDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->ToString();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_FunctionDefinition_FromString__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
  RobotRaconteur::FunctionDefinition *arg1 = (RobotRaconteur::FunctionDefinition *) 0 ;
  std::string *arg2 = 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  boost::shared_ptr< RobotRaconteur::FunctionDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::FunctionDefinition > *)jarg1;
  arg1 = (RobotRaconteur::FunctionDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg3; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2,(RobotRaconteur::ServiceDefinitionParseInfo const *)arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_FunctionDefinition_FromString__SWIG_1(void * jarg1, char * jarg2) {
  RobotRaconteur::FunctionDefinition *arg1 = (RobotRaconteur::FunctionDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::FunctionDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::FunctionDefinition > *)jarg1;
  arg1 = (RobotRaconteur::FunctionDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_FunctionDefinition_IsGenerator(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::FunctionDefinition *arg1 = (RobotRaconteur::FunctionDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::FunctionDefinition > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::FunctionDefinition > *)jarg1;
  arg1 = (RobotRaconteur::FunctionDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->IsGenerator();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_FunctionDefinition(void * jarg1) {
  RobotRaconteur::FunctionDefinition *arg1 = (RobotRaconteur::FunctionDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::FunctionDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::FunctionDefinition > *)jarg1;
  arg1 = (RobotRaconteur::FunctionDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_EventDefinition_Parameters_set(void * jarg1, void * jarg2) {
  RobotRaconteur::EventDefinition *arg1 = (RobotRaconteur::EventDefinition *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *) 0 ;
  boost::shared_ptr< RobotRaconteur::EventDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::EventDefinition > *)jarg1;
  arg1 = (RobotRaconteur::EventDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)jarg2; 
  if (arg1) (arg1)->Parameters = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_EventDefinition_Parameters_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::EventDefinition *arg1 = (RobotRaconteur::EventDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::EventDefinition > *smartarg1 = 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::EventDefinition > *)jarg1;
  arg1 = (RobotRaconteur::EventDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)& ((arg1)->Parameters);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_EventDefinition(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > tempnull1 ;
  RobotRaconteur::EventDefinition *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *)jarg1 : &tempnull1; 
  
  try {
    result = (RobotRaconteur::EventDefinition *)new RobotRaconteur::EventDefinition((boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::EventDefinition >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_EventDefinition_ToString(void * jarg1) {
  char * jresult ;
  RobotRaconteur::EventDefinition *arg1 = (RobotRaconteur::EventDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::EventDefinition > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::EventDefinition > *)jarg1;
  arg1 = (RobotRaconteur::EventDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->ToString();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_EventDefinition_FromString__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
  RobotRaconteur::EventDefinition *arg1 = (RobotRaconteur::EventDefinition *) 0 ;
  std::string *arg2 = 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  boost::shared_ptr< RobotRaconteur::EventDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::EventDefinition > *)jarg1;
  arg1 = (RobotRaconteur::EventDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg3; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2,(RobotRaconteur::ServiceDefinitionParseInfo const *)arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_EventDefinition_FromString__SWIG_1(void * jarg1, char * jarg2) {
  RobotRaconteur::EventDefinition *arg1 = (RobotRaconteur::EventDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::EventDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::EventDefinition > *)jarg1;
  arg1 = (RobotRaconteur::EventDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_EventDefinition(void * jarg1) {
  RobotRaconteur::EventDefinition *arg1 = (RobotRaconteur::EventDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::EventDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::EventDefinition > *)jarg1;
  arg1 = (RobotRaconteur::EventDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ObjRefDefinition_ObjectType_set(void * jarg1, char * jarg2) {
  RobotRaconteur::ObjRefDefinition *arg1 = (RobotRaconteur::ObjRefDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::ObjRefDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ObjRefDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ObjRefDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->ObjectType = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ObjRefDefinition_ObjectType_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::ObjRefDefinition *arg1 = (RobotRaconteur::ObjRefDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ObjRefDefinition > *smartarg1 = 0 ;
  std::string *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ObjRefDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ObjRefDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::string *) & ((arg1)->ObjectType);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ObjRefDefinition_ArrayType_set(void * jarg1, int jarg2) {
  RobotRaconteur::ObjRefDefinition *arg1 = (RobotRaconteur::ObjRefDefinition *) 0 ;
  RobotRaconteur::DataTypes_ArrayTypes arg2 ;
  boost::shared_ptr< RobotRaconteur::ObjRefDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ObjRefDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ObjRefDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::DataTypes_ArrayTypes)jarg2; 
  if (arg1) (arg1)->ArrayType = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_ObjRefDefinition_ArrayType_get(void * jarg1) {
  int jresult ;
  RobotRaconteur::ObjRefDefinition *arg1 = (RobotRaconteur::ObjRefDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ObjRefDefinition > *smartarg1 = 0 ;
  RobotRaconteur::DataTypes_ArrayTypes result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ObjRefDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ObjRefDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (RobotRaconteur::DataTypes_ArrayTypes) ((arg1)->ArrayType);
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ObjRefDefinition_ContainerType_set(void * jarg1, int jarg2) {
  RobotRaconteur::ObjRefDefinition *arg1 = (RobotRaconteur::ObjRefDefinition *) 0 ;
  RobotRaconteur::DataTypes_ContainerTypes arg2 ;
  boost::shared_ptr< RobotRaconteur::ObjRefDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ObjRefDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ObjRefDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::DataTypes_ContainerTypes)jarg2; 
  if (arg1) (arg1)->ContainerType = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_ObjRefDefinition_ContainerType_get(void * jarg1) {
  int jresult ;
  RobotRaconteur::ObjRefDefinition *arg1 = (RobotRaconteur::ObjRefDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ObjRefDefinition > *smartarg1 = 0 ;
  RobotRaconteur::DataTypes_ContainerTypes result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ObjRefDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ObjRefDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (RobotRaconteur::DataTypes_ContainerTypes) ((arg1)->ContainerType);
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_ObjRefDefinition(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > tempnull1 ;
  RobotRaconteur::ObjRefDefinition *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *)jarg1 : &tempnull1; 
  
  try {
    result = (RobotRaconteur::ObjRefDefinition *)new RobotRaconteur::ObjRefDefinition((boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::ObjRefDefinition >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ObjRefDefinition_ToString(void * jarg1) {
  char * jresult ;
  RobotRaconteur::ObjRefDefinition *arg1 = (RobotRaconteur::ObjRefDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ObjRefDefinition > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ObjRefDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ObjRefDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->ToString();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ObjRefDefinition_FromString__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
  RobotRaconteur::ObjRefDefinition *arg1 = (RobotRaconteur::ObjRefDefinition *) 0 ;
  std::string *arg2 = 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  boost::shared_ptr< RobotRaconteur::ObjRefDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ObjRefDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ObjRefDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg3; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2,(RobotRaconteur::ServiceDefinitionParseInfo const *)arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ObjRefDefinition_FromString__SWIG_1(void * jarg1, char * jarg2) {
  RobotRaconteur::ObjRefDefinition *arg1 = (RobotRaconteur::ObjRefDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::ObjRefDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ObjRefDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ObjRefDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_ObjRefDefinition(void * jarg1) {
  RobotRaconteur::ObjRefDefinition *arg1 = (RobotRaconteur::ObjRefDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ObjRefDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ObjRefDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ObjRefDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_PipeDefinition_Type_set(void * jarg1, void * jarg2) {
  RobotRaconteur::PipeDefinition *arg1 = (RobotRaconteur::PipeDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::PipeDefinition > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::PipeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::PipeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::TypeDefinition > *)jarg2 : &tempnull2; 
  if (arg1) (arg1)->Type = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_PipeDefinition_Type_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::PipeDefinition *arg1 = (RobotRaconteur::PipeDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::PipeDefinition > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::PipeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::PipeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (boost::shared_ptr< RobotRaconteur::TypeDefinition > *) & ((arg1)->Type);
  jresult = *result ? new boost::shared_ptr< RobotRaconteur::TypeDefinition >(*result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_PipeDefinition(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > tempnull1 ;
  RobotRaconteur::PipeDefinition *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *)jarg1 : &tempnull1; 
  
  try {
    result = (RobotRaconteur::PipeDefinition *)new RobotRaconteur::PipeDefinition((boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::PipeDefinition >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_PipeDefinition_ToString(void * jarg1) {
  char * jresult ;
  RobotRaconteur::PipeDefinition *arg1 = (RobotRaconteur::PipeDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::PipeDefinition > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::PipeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::PipeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->ToString();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_PipeDefinition_FromString__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
  RobotRaconteur::PipeDefinition *arg1 = (RobotRaconteur::PipeDefinition *) 0 ;
  std::string *arg2 = 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  boost::shared_ptr< RobotRaconteur::PipeDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::PipeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::PipeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg3; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2,(RobotRaconteur::ServiceDefinitionParseInfo const *)arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_PipeDefinition_FromString__SWIG_1(void * jarg1, char * jarg2) {
  RobotRaconteur::PipeDefinition *arg1 = (RobotRaconteur::PipeDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::PipeDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::PipeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::PipeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_PipeDefinition(void * jarg1) {
  RobotRaconteur::PipeDefinition *arg1 = (RobotRaconteur::PipeDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::PipeDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::PipeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::PipeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_CallbackDefinition_ReturnType_set(void * jarg1, void * jarg2) {
  RobotRaconteur::CallbackDefinition *arg1 = (RobotRaconteur::CallbackDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::CallbackDefinition > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::CallbackDefinition > *)jarg1;
  arg1 = (RobotRaconteur::CallbackDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::TypeDefinition > *)jarg2 : &tempnull2; 
  if (arg1) (arg1)->ReturnType = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_CallbackDefinition_ReturnType_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::CallbackDefinition *arg1 = (RobotRaconteur::CallbackDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::CallbackDefinition > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::CallbackDefinition > *)jarg1;
  arg1 = (RobotRaconteur::CallbackDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (boost::shared_ptr< RobotRaconteur::TypeDefinition > *) & ((arg1)->ReturnType);
  jresult = *result ? new boost::shared_ptr< RobotRaconteur::TypeDefinition >(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_CallbackDefinition_Parameters_set(void * jarg1, void * jarg2) {
  RobotRaconteur::CallbackDefinition *arg1 = (RobotRaconteur::CallbackDefinition *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *) 0 ;
  boost::shared_ptr< RobotRaconteur::CallbackDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::CallbackDefinition > *)jarg1;
  arg1 = (RobotRaconteur::CallbackDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)jarg2; 
  if (arg1) (arg1)->Parameters = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_CallbackDefinition_Parameters_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::CallbackDefinition *arg1 = (RobotRaconteur::CallbackDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::CallbackDefinition > *smartarg1 = 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::CallbackDefinition > *)jarg1;
  arg1 = (RobotRaconteur::CallbackDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::vector< boost::shared_ptr< RobotRaconteur::TypeDefinition > > *)& ((arg1)->Parameters);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_CallbackDefinition(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > tempnull1 ;
  RobotRaconteur::CallbackDefinition *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *)jarg1 : &tempnull1; 
  
  try {
    result = (RobotRaconteur::CallbackDefinition *)new RobotRaconteur::CallbackDefinition((boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::CallbackDefinition >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_CallbackDefinition_ToString(void * jarg1) {
  char * jresult ;
  RobotRaconteur::CallbackDefinition *arg1 = (RobotRaconteur::CallbackDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::CallbackDefinition > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::CallbackDefinition > *)jarg1;
  arg1 = (RobotRaconteur::CallbackDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->ToString();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_CallbackDefinition_FromString__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
  RobotRaconteur::CallbackDefinition *arg1 = (RobotRaconteur::CallbackDefinition *) 0 ;
  std::string *arg2 = 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  boost::shared_ptr< RobotRaconteur::CallbackDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::CallbackDefinition > *)jarg1;
  arg1 = (RobotRaconteur::CallbackDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg3; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2,(RobotRaconteur::ServiceDefinitionParseInfo const *)arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_CallbackDefinition_FromString__SWIG_1(void * jarg1, char * jarg2) {
  RobotRaconteur::CallbackDefinition *arg1 = (RobotRaconteur::CallbackDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::CallbackDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::CallbackDefinition > *)jarg1;
  arg1 = (RobotRaconteur::CallbackDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_CallbackDefinition(void * jarg1) {
  RobotRaconteur::CallbackDefinition *arg1 = (RobotRaconteur::CallbackDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::CallbackDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::CallbackDefinition > *)jarg1;
  arg1 = (RobotRaconteur::CallbackDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WireDefinition_Type_set(void * jarg1, void * jarg2) {
  RobotRaconteur::WireDefinition *arg1 = (RobotRaconteur::WireDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WireDefinition > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WireDefinition > *)jarg1;
  arg1 = (RobotRaconteur::WireDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::TypeDefinition > *)jarg2 : &tempnull2; 
  if (arg1) (arg1)->Type = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WireDefinition_Type_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WireDefinition *arg1 = (RobotRaconteur::WireDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::WireDefinition > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WireDefinition > *)jarg1;
  arg1 = (RobotRaconteur::WireDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (boost::shared_ptr< RobotRaconteur::TypeDefinition > *) & ((arg1)->Type);
  jresult = *result ? new boost::shared_ptr< RobotRaconteur::TypeDefinition >(*result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WireDefinition(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > tempnull1 ;
  RobotRaconteur::WireDefinition *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *)jarg1 : &tempnull1; 
  
  try {
    result = (RobotRaconteur::WireDefinition *)new RobotRaconteur::WireDefinition((boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::WireDefinition >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_WireDefinition_ToString(void * jarg1) {
  char * jresult ;
  RobotRaconteur::WireDefinition *arg1 = (RobotRaconteur::WireDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::WireDefinition > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WireDefinition > *)jarg1;
  arg1 = (RobotRaconteur::WireDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->ToString();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WireDefinition_FromString__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
  RobotRaconteur::WireDefinition *arg1 = (RobotRaconteur::WireDefinition *) 0 ;
  std::string *arg2 = 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  boost::shared_ptr< RobotRaconteur::WireDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WireDefinition > *)jarg1;
  arg1 = (RobotRaconteur::WireDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg3; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2,(RobotRaconteur::ServiceDefinitionParseInfo const *)arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WireDefinition_FromString__SWIG_1(void * jarg1, char * jarg2) {
  RobotRaconteur::WireDefinition *arg1 = (RobotRaconteur::WireDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WireDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WireDefinition > *)jarg1;
  arg1 = (RobotRaconteur::WireDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WireDefinition(void * jarg1) {
  RobotRaconteur::WireDefinition *arg1 = (RobotRaconteur::WireDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::WireDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WireDefinition > *)jarg1;
  arg1 = (RobotRaconteur::WireDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MemoryDefinition_Type_set(void * jarg1, void * jarg2) {
  RobotRaconteur::MemoryDefinition *arg1 = (RobotRaconteur::MemoryDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::MemoryDefinition > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::MemoryDefinition > *)jarg1;
  arg1 = (RobotRaconteur::MemoryDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::TypeDefinition > *)jarg2 : &tempnull2; 
  if (arg1) (arg1)->Type = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MemoryDefinition_Type_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::MemoryDefinition *arg1 = (RobotRaconteur::MemoryDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::MemoryDefinition > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::MemoryDefinition > *)jarg1;
  arg1 = (RobotRaconteur::MemoryDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (boost::shared_ptr< RobotRaconteur::TypeDefinition > *) & ((arg1)->Type);
  jresult = *result ? new boost::shared_ptr< RobotRaconteur::TypeDefinition >(*result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_MemoryDefinition(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > tempnull1 ;
  RobotRaconteur::MemoryDefinition *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *)jarg1 : &tempnull1; 
  
  try {
    result = (RobotRaconteur::MemoryDefinition *)new RobotRaconteur::MemoryDefinition((boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::MemoryDefinition >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_MemoryDefinition_ToString(void * jarg1) {
  char * jresult ;
  RobotRaconteur::MemoryDefinition *arg1 = (RobotRaconteur::MemoryDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::MemoryDefinition > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::MemoryDefinition > *)jarg1;
  arg1 = (RobotRaconteur::MemoryDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->ToString();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MemoryDefinition_FromString__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
  RobotRaconteur::MemoryDefinition *arg1 = (RobotRaconteur::MemoryDefinition *) 0 ;
  std::string *arg2 = 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  boost::shared_ptr< RobotRaconteur::MemoryDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::MemoryDefinition > *)jarg1;
  arg1 = (RobotRaconteur::MemoryDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg3; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2,(RobotRaconteur::ServiceDefinitionParseInfo const *)arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MemoryDefinition_FromString__SWIG_1(void * jarg1, char * jarg2) {
  RobotRaconteur::MemoryDefinition *arg1 = (RobotRaconteur::MemoryDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::MemoryDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::MemoryDefinition > *)jarg1;
  arg1 = (RobotRaconteur::MemoryDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_MemoryDefinition(void * jarg1) {
  RobotRaconteur::MemoryDefinition *arg1 = (RobotRaconteur::MemoryDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::MemoryDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::MemoryDefinition > *)jarg1;
  arg1 = (RobotRaconteur::MemoryDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TypeDefinition_Name_set(void * jarg1, char * jarg2) {
  RobotRaconteur::TypeDefinition *arg1 = (RobotRaconteur::TypeDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TypeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::TypeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->Name = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_TypeDefinition_Name_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::TypeDefinition *arg1 = (RobotRaconteur::TypeDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *smartarg1 = 0 ;
  std::string *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TypeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::TypeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::string *) & ((arg1)->Name);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TypeDefinition_Type_set(void * jarg1, int jarg2) {
  RobotRaconteur::TypeDefinition *arg1 = (RobotRaconteur::TypeDefinition *) 0 ;
  RobotRaconteur::DataTypes arg2 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TypeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::TypeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::DataTypes)jarg2; 
  if (arg1) (arg1)->Type = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_TypeDefinition_Type_get(void * jarg1) {
  int jresult ;
  RobotRaconteur::TypeDefinition *arg1 = (RobotRaconteur::TypeDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *smartarg1 = 0 ;
  RobotRaconteur::DataTypes result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TypeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::TypeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (RobotRaconteur::DataTypes) ((arg1)->Type);
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TypeDefinition_TypeString_set(void * jarg1, char * jarg2) {
  RobotRaconteur::TypeDefinition *arg1 = (RobotRaconteur::TypeDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TypeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::TypeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->TypeString = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_TypeDefinition_TypeString_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::TypeDefinition *arg1 = (RobotRaconteur::TypeDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *smartarg1 = 0 ;
  std::string *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TypeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::TypeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::string *) & ((arg1)->TypeString);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TypeDefinition_ArrayType_set(void * jarg1, int jarg2) {
  RobotRaconteur::TypeDefinition *arg1 = (RobotRaconteur::TypeDefinition *) 0 ;
  RobotRaconteur::DataTypes_ArrayTypes arg2 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TypeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::TypeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::DataTypes_ArrayTypes)jarg2; 
  if (arg1) (arg1)->ArrayType = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_TypeDefinition_ArrayType_get(void * jarg1) {
  int jresult ;
  RobotRaconteur::TypeDefinition *arg1 = (RobotRaconteur::TypeDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *smartarg1 = 0 ;
  RobotRaconteur::DataTypes_ArrayTypes result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TypeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::TypeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (RobotRaconteur::DataTypes_ArrayTypes) ((arg1)->ArrayType);
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TypeDefinition_ArrayVarLength_set(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::TypeDefinition *arg1 = (RobotRaconteur::TypeDefinition *) 0 ;
  bool arg2 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TypeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::TypeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->ArrayVarLength = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TypeDefinition_ArrayVarLength_get(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::TypeDefinition *arg1 = (RobotRaconteur::TypeDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TypeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::TypeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (bool) ((arg1)->ArrayVarLength);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TypeDefinition_ArrayLength_set(void * jarg1, void * jarg2) {
  RobotRaconteur::TypeDefinition *arg1 = (RobotRaconteur::TypeDefinition *) 0 ;
  std::vector< int32_t > *arg2 = (std::vector< int32_t > *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TypeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::TypeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< int32_t > *)jarg2; 
  if (arg1) (arg1)->ArrayLength = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_TypeDefinition_ArrayLength_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::TypeDefinition *arg1 = (RobotRaconteur::TypeDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *smartarg1 = 0 ;
  std::vector< int32_t > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TypeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::TypeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::vector< int32_t > *)& ((arg1)->ArrayLength);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TypeDefinition_ContainerType_set(void * jarg1, int jarg2) {
  RobotRaconteur::TypeDefinition *arg1 = (RobotRaconteur::TypeDefinition *) 0 ;
  RobotRaconteur::DataTypes_ContainerTypes arg2 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TypeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::TypeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::DataTypes_ContainerTypes)jarg2; 
  if (arg1) (arg1)->ContainerType = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_TypeDefinition_ContainerType_get(void * jarg1) {
  int jresult ;
  RobotRaconteur::TypeDefinition *arg1 = (RobotRaconteur::TypeDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *smartarg1 = 0 ;
  RobotRaconteur::DataTypes_ContainerTypes result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TypeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::TypeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (RobotRaconteur::DataTypes_ContainerTypes) ((arg1)->ContainerType);
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_TypeDefinition__SWIG_0() {
  void * jresult ;
  RobotRaconteur::TypeDefinition *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::TypeDefinition *)new RobotRaconteur::TypeDefinition();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::TypeDefinition >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_TypeDefinition_ToString(void * jarg1) {
  char * jresult ;
  RobotRaconteur::TypeDefinition *arg1 = (RobotRaconteur::TypeDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TypeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::TypeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->ToString();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TypeDefinition_FromString__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
  RobotRaconteur::TypeDefinition *arg1 = (RobotRaconteur::TypeDefinition *) 0 ;
  std::string *arg2 = 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TypeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::TypeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg3; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2,(RobotRaconteur::ServiceDefinitionParseInfo const *)arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TypeDefinition_FromString__SWIG_1(void * jarg1, char * jarg2) {
  RobotRaconteur::TypeDefinition *arg1 = (RobotRaconteur::TypeDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TypeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::TypeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_TypeDefinition_DataTypeFromString(char * jarg1) {
  int jresult ;
  std::string *arg1 = 0 ;
  RobotRaconteur::DataTypes result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  
  try {
    result = (RobotRaconteur::DataTypes)RobotRaconteur::TypeDefinition::DataTypeFromString((std::string const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_TypeDefinition_StringFromDataType(int jarg1) {
  char * jresult ;
  RobotRaconteur::DataTypes arg1 ;
  std::string result;
  
  arg1 = (RobotRaconteur::DataTypes)jarg1; 
  
  try {
    result = RobotRaconteur::TypeDefinition::StringFromDataType(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_TypeDefinition__GetMember(void * jarg1) {
  void * jresult ;
  RobotRaconteur::TypeDefinition *arg1 = (RobotRaconteur::TypeDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TypeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::TypeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = RobotRaconteur_TypeDefinition_GetMember(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::MemberDefinition >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TypeDefinition__SetMember(void * jarg1, void * jarg2) {
  RobotRaconteur::TypeDefinition *arg1 = (RobotRaconteur::TypeDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TypeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::TypeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::MemberDefinition > *)jarg2 : &tempnull2; 
  
  try {
    RobotRaconteur_TypeDefinition_SetMember(arg1,(boost::shared_ptr< RobotRaconteur::MemberDefinition > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TypeDefinition_CopyTo(void * jarg1, void * jarg2) {
  RobotRaconteur::TypeDefinition *arg1 = (RobotRaconteur::TypeDefinition *) 0 ;
  RobotRaconteur::TypeDefinition *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition const > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr< const RobotRaconteur::TypeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::TypeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  arg2 = (RobotRaconteur::TypeDefinition *)(((boost::shared_ptr<  RobotRaconteur::TypeDefinition > *)jarg2) ? ((boost::shared_ptr<  RobotRaconteur::TypeDefinition > *)jarg2)->get() : 0);
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::TypeDefinition & reference is null", 0);
    return ;
  } 
  
  try {
    ((RobotRaconteur::TypeDefinition const *)arg1)->CopyTo(*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_TypeDefinition_Clone(void * jarg1) {
  void * jresult ;
  RobotRaconteur::TypeDefinition *arg1 = (RobotRaconteur::TypeDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition const > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > result;
  
  
  smartarg1 = (boost::shared_ptr< const RobotRaconteur::TypeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::TypeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = ((RobotRaconteur::TypeDefinition const *)arg1)->Clone();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::TypeDefinition >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TypeDefinition_Rename(void * jarg1, char * jarg2) {
  RobotRaconteur::TypeDefinition *arg1 = (RobotRaconteur::TypeDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TypeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::TypeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->Rename((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TypeDefinition_RemoveContainers(void * jarg1) {
  RobotRaconteur::TypeDefinition *arg1 = (RobotRaconteur::TypeDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TypeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::TypeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->RemoveContainers();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TypeDefinition_RemoveArray(void * jarg1) {
  RobotRaconteur::TypeDefinition *arg1 = (RobotRaconteur::TypeDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TypeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::TypeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->RemoveArray();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TypeDefinition_QualifyTypeStringWithUsing(void * jarg1) {
  RobotRaconteur::TypeDefinition *arg1 = (RobotRaconteur::TypeDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TypeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::TypeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->QualifyTypeStringWithUsing();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TypeDefinition_UnqualifyTypeStringWithUsing(void * jarg1) {
  RobotRaconteur::TypeDefinition *arg1 = (RobotRaconteur::TypeDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TypeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::TypeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->UnqualifyTypeStringWithUsing();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TypeDefinition_Reset(void * jarg1) {
  RobotRaconteur::TypeDefinition *arg1 = (RobotRaconteur::TypeDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TypeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::TypeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->Reset();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_TypeDefinition__SWIG_1(void * jarg1) {
  void * jresult ;
  RobotRaconteur::TypeDefinition *arg1 = 0 ;
  RobotRaconteur::TypeDefinition *result = 0 ;
  
  
  arg1 = (RobotRaconteur::TypeDefinition *)(((boost::shared_ptr< const RobotRaconteur::TypeDefinition > *)jarg1) ? ((boost::shared_ptr< const RobotRaconteur::TypeDefinition > *)jarg1)->get() : 0);
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::TypeDefinition const & reference is null", 0);
    return 0;
  } 
  
  try {
    result = (RobotRaconteur::TypeDefinition *)new RobotRaconteur::TypeDefinition((RobotRaconteur::TypeDefinition const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::TypeDefinition >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_TypeDefinition(void * jarg1) {
  RobotRaconteur::TypeDefinition *arg1 = (RobotRaconteur::TypeDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TypeDefinition > *)jarg1;
  arg1 = (RobotRaconteur::TypeDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_UsingDefinition(void * jarg1) {
  RobotRaconteur::UsingDefinition *arg1 = (RobotRaconteur::UsingDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::UsingDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::UsingDefinition > *)jarg1;
  arg1 = (RobotRaconteur::UsingDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_UsingDefinition_QualifiedName_set(void * jarg1, char * jarg2) {
  RobotRaconteur::UsingDefinition *arg1 = (RobotRaconteur::UsingDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::UsingDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::UsingDefinition > *)jarg1;
  arg1 = (RobotRaconteur::UsingDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->QualifiedName = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_UsingDefinition_QualifiedName_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::UsingDefinition *arg1 = (RobotRaconteur::UsingDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::UsingDefinition > *smartarg1 = 0 ;
  std::string *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::UsingDefinition > *)jarg1;
  arg1 = (RobotRaconteur::UsingDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::string *) & ((arg1)->QualifiedName);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_UsingDefinition_UnqualifiedName_set(void * jarg1, char * jarg2) {
  RobotRaconteur::UsingDefinition *arg1 = (RobotRaconteur::UsingDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::UsingDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::UsingDefinition > *)jarg1;
  arg1 = (RobotRaconteur::UsingDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->UnqualifiedName = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_UsingDefinition_UnqualifiedName_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::UsingDefinition *arg1 = (RobotRaconteur::UsingDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::UsingDefinition > *smartarg1 = 0 ;
  std::string *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::UsingDefinition > *)jarg1;
  arg1 = (RobotRaconteur::UsingDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::string *) & ((arg1)->UnqualifiedName);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_UsingDefinition_ParseInfo_set(void * jarg1, void * jarg2) {
  RobotRaconteur::UsingDefinition *arg1 = (RobotRaconteur::UsingDefinition *) 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *arg2 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  boost::shared_ptr< RobotRaconteur::UsingDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::UsingDefinition > *)jarg1;
  arg1 = (RobotRaconteur::UsingDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg2; 
  if (arg1) (arg1)->ParseInfo = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_UsingDefinition_ParseInfo_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::UsingDefinition *arg1 = (RobotRaconteur::UsingDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::UsingDefinition > *smartarg1 = 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::UsingDefinition > *)jarg1;
  arg1 = (RobotRaconteur::UsingDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (RobotRaconteur::ServiceDefinitionParseInfo *)& ((arg1)->ParseInfo);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_UsingDefinition__GetService(void * jarg1) {
  void * jresult ;
  RobotRaconteur::UsingDefinition *arg1 = (RobotRaconteur::UsingDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::UsingDefinition > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::UsingDefinition > *)jarg1;
  arg1 = (RobotRaconteur::UsingDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = RobotRaconteur_UsingDefinition_GetService(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::ServiceDefinition >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_UsingDefinition__SetService(void * jarg1, void * jarg2) {
  RobotRaconteur::UsingDefinition *arg1 = (RobotRaconteur::UsingDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::UsingDefinition > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::UsingDefinition > *)jarg1;
  arg1 = (RobotRaconteur::UsingDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::ServiceDefinition > *)jarg2 : &tempnull2; 
  
  try {
    RobotRaconteur_UsingDefinition_SetService(arg1,(boost::shared_ptr< RobotRaconteur::ServiceDefinition > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_UsingDefinition(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > tempnull1 ;
  RobotRaconteur::UsingDefinition *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::ServiceDefinition > *)jarg1 : &tempnull1; 
  
  try {
    result = (RobotRaconteur::UsingDefinition *)new RobotRaconteur::UsingDefinition((boost::shared_ptr< RobotRaconteur::ServiceDefinition > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::UsingDefinition >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_UsingDefinition_ToString(void * jarg1) {
  char * jresult ;
  RobotRaconteur::UsingDefinition *arg1 = (RobotRaconteur::UsingDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::UsingDefinition > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::UsingDefinition > *)jarg1;
  arg1 = (RobotRaconteur::UsingDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->ToString();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_UsingDefinition_FromString__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
  RobotRaconteur::UsingDefinition *arg1 = (RobotRaconteur::UsingDefinition *) 0 ;
  std::string *arg2 = 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  boost::shared_ptr< RobotRaconteur::UsingDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::UsingDefinition > *)jarg1;
  arg1 = (RobotRaconteur::UsingDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg3; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2,(RobotRaconteur::ServiceDefinitionParseInfo const *)arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_UsingDefinition_FromString__SWIG_1(void * jarg1, char * jarg2) {
  RobotRaconteur::UsingDefinition *arg1 = (RobotRaconteur::UsingDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::UsingDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::UsingDefinition > *)jarg1;
  arg1 = (RobotRaconteur::UsingDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ConstantDefinition_StructField_Name_set(void * jarg1, char * jarg2) {
  RobotRaconteur::ConstantDefinition_StructField *arg1 = (RobotRaconteur::ConstantDefinition_StructField *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::ConstantDefinition_StructField *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->Name = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ConstantDefinition_StructField_Name_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::ConstantDefinition_StructField *arg1 = (RobotRaconteur::ConstantDefinition_StructField *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (RobotRaconteur::ConstantDefinition_StructField *)jarg1; 
  result = (std::string *) & ((arg1)->Name);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ConstantDefinition_StructField_ConstantRefName_set(void * jarg1, char * jarg2) {
  RobotRaconteur::ConstantDefinition_StructField *arg1 = (RobotRaconteur::ConstantDefinition_StructField *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::ConstantDefinition_StructField *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->ConstantRefName = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ConstantDefinition_StructField_ConstantRefName_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::ConstantDefinition_StructField *arg1 = (RobotRaconteur::ConstantDefinition_StructField *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (RobotRaconteur::ConstantDefinition_StructField *)jarg1; 
  result = (std::string *) & ((arg1)->ConstantRefName);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_ConstantDefinition_StructField() {
  void * jresult ;
  RobotRaconteur::ConstantDefinition_StructField *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::ConstantDefinition_StructField *)new RobotRaconteur::ConstantDefinition_StructField();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_ConstantDefinition_StructField(void * jarg1) {
  RobotRaconteur::ConstantDefinition_StructField *arg1 = (RobotRaconteur::ConstantDefinition_StructField *) 0 ;
  
  arg1 = (RobotRaconteur::ConstantDefinition_StructField *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_ConstantDefinition(void * jarg1) {
  RobotRaconteur::ConstantDefinition *arg1 = (RobotRaconteur::ConstantDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ConstantDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ConstantDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ConstantDefinition_Name_set(void * jarg1, char * jarg2) {
  RobotRaconteur::ConstantDefinition *arg1 = (RobotRaconteur::ConstantDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ConstantDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ConstantDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->Name = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ConstantDefinition_Name_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::ConstantDefinition *arg1 = (RobotRaconteur::ConstantDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > *smartarg1 = 0 ;
  std::string *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ConstantDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ConstantDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::string *) & ((arg1)->Name);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ConstantDefinition_DocString_set(void * jarg1, char * jarg2) {
  RobotRaconteur::ConstantDefinition *arg1 = (RobotRaconteur::ConstantDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ConstantDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ConstantDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->DocString = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ConstantDefinition_DocString_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::ConstantDefinition *arg1 = (RobotRaconteur::ConstantDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > *smartarg1 = 0 ;
  std::string *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ConstantDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ConstantDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::string *) & ((arg1)->DocString);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ConstantDefinition_Type_set(void * jarg1, void * jarg2) {
  RobotRaconteur::ConstantDefinition *arg1 = (RobotRaconteur::ConstantDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ConstantDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ConstantDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::TypeDefinition > *)jarg2 : &tempnull2; 
  if (arg1) (arg1)->Type = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ConstantDefinition_Type_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ConstantDefinition *arg1 = (RobotRaconteur::ConstantDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ConstantDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ConstantDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (boost::shared_ptr< RobotRaconteur::TypeDefinition > *) & ((arg1)->Type);
  jresult = *result ? new boost::shared_ptr< RobotRaconteur::TypeDefinition >(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ConstantDefinition_Value_set(void * jarg1, char * jarg2) {
  RobotRaconteur::ConstantDefinition *arg1 = (RobotRaconteur::ConstantDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ConstantDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ConstantDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->Value = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ConstantDefinition_Value_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::ConstantDefinition *arg1 = (RobotRaconteur::ConstantDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > *smartarg1 = 0 ;
  std::string *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ConstantDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ConstantDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::string *) & ((arg1)->Value);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ConstantDefinition_ParseInfo_set(void * jarg1, void * jarg2) {
  RobotRaconteur::ConstantDefinition *arg1 = (RobotRaconteur::ConstantDefinition *) 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *arg2 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ConstantDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ConstantDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg2; 
  if (arg1) (arg1)->ParseInfo = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ConstantDefinition_ParseInfo_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ConstantDefinition *arg1 = (RobotRaconteur::ConstantDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > *smartarg1 = 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ConstantDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ConstantDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (RobotRaconteur::ServiceDefinitionParseInfo *)& ((arg1)->ParseInfo);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ConstantDefinition__GetService(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ConstantDefinition *arg1 = (RobotRaconteur::ConstantDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ConstantDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ConstantDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = RobotRaconteur_ConstantDefinition_GetService(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::ServiceDefinition >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ConstantDefinition__SetService(void * jarg1, void * jarg2) {
  RobotRaconteur::ConstantDefinition *arg1 = (RobotRaconteur::ConstantDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ConstantDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ConstantDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::ServiceDefinition > *)jarg2 : &tempnull2; 
  
  try {
    RobotRaconteur_ConstantDefinition_SetService(arg1,(boost::shared_ptr< RobotRaconteur::ServiceDefinition > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ConstantDefinition__GetServiceEntry(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ConstantDefinition *arg1 = (RobotRaconteur::ConstantDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ConstantDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ConstantDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = RobotRaconteur_ConstantDefinition_GetServiceEntry(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ConstantDefinition__SetServiceEntry(void * jarg1, void * jarg2) {
  RobotRaconteur::ConstantDefinition *arg1 = (RobotRaconteur::ConstantDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ConstantDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ConstantDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *)jarg2 : &tempnull2; 
  
  try {
    RobotRaconteur_ConstantDefinition_SetServiceEntry(arg1,(boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_ConstantDefinition__SWIG_0(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > tempnull1 ;
  RobotRaconteur::ConstantDefinition *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::ServiceDefinition > *)jarg1 : &tempnull1; 
  
  try {
    result = (RobotRaconteur::ConstantDefinition *)new RobotRaconteur::ConstantDefinition((boost::shared_ptr< RobotRaconteur::ServiceDefinition > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::ConstantDefinition >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_ConstantDefinition__SWIG_1(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > tempnull1 ;
  RobotRaconteur::ConstantDefinition *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *)jarg1 : &tempnull1; 
  
  try {
    result = (RobotRaconteur::ConstantDefinition *)new RobotRaconteur::ConstantDefinition((boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::ConstantDefinition >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ConstantDefinition_ToString(void * jarg1) {
  char * jresult ;
  RobotRaconteur::ConstantDefinition *arg1 = (RobotRaconteur::ConstantDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ConstantDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ConstantDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->ToString();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ConstantDefinition_FromString__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
  RobotRaconteur::ConstantDefinition *arg1 = (RobotRaconteur::ConstantDefinition *) 0 ;
  std::string *arg2 = 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ConstantDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ConstantDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg3; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2,(RobotRaconteur::ServiceDefinitionParseInfo const *)arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ConstantDefinition_FromString__SWIG_1(void * jarg1, char * jarg2) {
  RobotRaconteur::ConstantDefinition *arg1 = (RobotRaconteur::ConstantDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ConstantDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ConstantDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ConstantDefinition_Reset(void * jarg1) {
  RobotRaconteur::ConstantDefinition *arg1 = (RobotRaconteur::ConstantDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ConstantDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ConstantDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->Reset();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_ConstantDefinition_VerifyValue(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::ConstantDefinition *arg1 = (RobotRaconteur::ConstantDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ConstantDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ConstantDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->VerifyValue();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ConstantDefinition_ValueToString(void * jarg1) {
  char * jresult ;
  RobotRaconteur::ConstantDefinition *arg1 = (RobotRaconteur::ConstantDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ConstantDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ConstantDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->ValueToString();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ConstantDefinition_ValueToStructFields(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ConstantDefinition *arg1 = (RobotRaconteur::ConstantDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ConstantDefinition > *smartarg1 = 0 ;
  std::vector< RobotRaconteur::ConstantDefinition_StructField > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ConstantDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ConstantDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->ValueToStructFields();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< RobotRaconteur::ConstantDefinition_StructField >((const std::vector< RobotRaconteur::ConstantDefinition_StructField > &)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ConstantDefinition_UnescapeString(char * jarg1) {
  char * jresult ;
  std::string *arg1 = 0 ;
  std::string result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  
  try {
    result = RobotRaconteur::ConstantDefinition::UnescapeString((std::string const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ConstantDefinition_EscapeString(char * jarg1) {
  char * jresult ;
  std::string *arg1 = 0 ;
  std::string result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  
  try {
    result = RobotRaconteur::ConstantDefinition::EscapeString((std::string const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_EnumDefinition(void * jarg1) {
  RobotRaconteur::EnumDefinition *arg1 = (RobotRaconteur::EnumDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::EnumDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::EnumDefinition > *)jarg1;
  arg1 = (RobotRaconteur::EnumDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_EnumDefinition_Name_set(void * jarg1, char * jarg2) {
  RobotRaconteur::EnumDefinition *arg1 = (RobotRaconteur::EnumDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::EnumDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::EnumDefinition > *)jarg1;
  arg1 = (RobotRaconteur::EnumDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->Name = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_EnumDefinition_Name_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::EnumDefinition *arg1 = (RobotRaconteur::EnumDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::EnumDefinition > *smartarg1 = 0 ;
  std::string *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::EnumDefinition > *)jarg1;
  arg1 = (RobotRaconteur::EnumDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::string *) & ((arg1)->Name);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_EnumDefinition_DocString_set(void * jarg1, char * jarg2) {
  RobotRaconteur::EnumDefinition *arg1 = (RobotRaconteur::EnumDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::EnumDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::EnumDefinition > *)jarg1;
  arg1 = (RobotRaconteur::EnumDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->DocString = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_EnumDefinition_DocString_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::EnumDefinition *arg1 = (RobotRaconteur::EnumDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::EnumDefinition > *smartarg1 = 0 ;
  std::string *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::EnumDefinition > *)jarg1;
  arg1 = (RobotRaconteur::EnumDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::string *) & ((arg1)->DocString);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_EnumDefinition_Values_set(void * jarg1, void * jarg2) {
  RobotRaconteur::EnumDefinition *arg1 = (RobotRaconteur::EnumDefinition *) 0 ;
  std::vector< RobotRaconteur::EnumDefinitionValue > *arg2 = (std::vector< RobotRaconteur::EnumDefinitionValue > *) 0 ;
  boost::shared_ptr< RobotRaconteur::EnumDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::EnumDefinition > *)jarg1;
  arg1 = (RobotRaconteur::EnumDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< RobotRaconteur::EnumDefinitionValue > *)jarg2; 
  if (arg1) (arg1)->Values = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_EnumDefinition_Values_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::EnumDefinition *arg1 = (RobotRaconteur::EnumDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::EnumDefinition > *smartarg1 = 0 ;
  std::vector< RobotRaconteur::EnumDefinitionValue > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::EnumDefinition > *)jarg1;
  arg1 = (RobotRaconteur::EnumDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::vector< RobotRaconteur::EnumDefinitionValue > *)& ((arg1)->Values);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_EnumDefinition_ParseInfo_set(void * jarg1, void * jarg2) {
  RobotRaconteur::EnumDefinition *arg1 = (RobotRaconteur::EnumDefinition *) 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *arg2 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  boost::shared_ptr< RobotRaconteur::EnumDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::EnumDefinition > *)jarg1;
  arg1 = (RobotRaconteur::EnumDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg2; 
  if (arg1) (arg1)->ParseInfo = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_EnumDefinition_ParseInfo_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::EnumDefinition *arg1 = (RobotRaconteur::EnumDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::EnumDefinition > *smartarg1 = 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::EnumDefinition > *)jarg1;
  arg1 = (RobotRaconteur::EnumDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (RobotRaconteur::ServiceDefinitionParseInfo *)& ((arg1)->ParseInfo);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_EnumDefinition__GetService(void * jarg1) {
  void * jresult ;
  RobotRaconteur::EnumDefinition *arg1 = (RobotRaconteur::EnumDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::EnumDefinition > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::EnumDefinition > *)jarg1;
  arg1 = (RobotRaconteur::EnumDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = RobotRaconteur_EnumDefinition_GetService(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::ServiceDefinition >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_EnumDefinition__SetService(void * jarg1, void * jarg2) {
  RobotRaconteur::EnumDefinition *arg1 = (RobotRaconteur::EnumDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::EnumDefinition > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::EnumDefinition > *)jarg1;
  arg1 = (RobotRaconteur::EnumDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::ServiceDefinition > *)jarg2 : &tempnull2; 
  
  try {
    RobotRaconteur_EnumDefinition_SetService(arg1,(boost::shared_ptr< RobotRaconteur::ServiceDefinition > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_EnumDefinition(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > tempnull1 ;
  RobotRaconteur::EnumDefinition *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::ServiceDefinition > *)jarg1 : &tempnull1; 
  
  try {
    result = (RobotRaconteur::EnumDefinition *)new RobotRaconteur::EnumDefinition((boost::shared_ptr< RobotRaconteur::ServiceDefinition > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::EnumDefinition >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_EnumDefinition_ToString(void * jarg1) {
  char * jresult ;
  RobotRaconteur::EnumDefinition *arg1 = (RobotRaconteur::EnumDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::EnumDefinition > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::EnumDefinition > *)jarg1;
  arg1 = (RobotRaconteur::EnumDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->ToString();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_EnumDefinition_FromString__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
  RobotRaconteur::EnumDefinition *arg1 = (RobotRaconteur::EnumDefinition *) 0 ;
  std::string *arg2 = 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  boost::shared_ptr< RobotRaconteur::EnumDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::EnumDefinition > *)jarg1;
  arg1 = (RobotRaconteur::EnumDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg3; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2,(RobotRaconteur::ServiceDefinitionParseInfo const *)arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_EnumDefinition_FromString__SWIG_1(void * jarg1, char * jarg2) {
  RobotRaconteur::EnumDefinition *arg1 = (RobotRaconteur::EnumDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::EnumDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::EnumDefinition > *)jarg1;
  arg1 = (RobotRaconteur::EnumDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_EnumDefinition_VerifyValues(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::EnumDefinition *arg1 = (RobotRaconteur::EnumDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::EnumDefinition > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::EnumDefinition > *)jarg1;
  arg1 = (RobotRaconteur::EnumDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->VerifyValues();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_EnumDefinition_Reset(void * jarg1) {
  RobotRaconteur::EnumDefinition *arg1 = (RobotRaconteur::EnumDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::EnumDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::EnumDefinition > *)jarg1;
  arg1 = (RobotRaconteur::EnumDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->Reset();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_EnumDefinitionValue() {
  void * jresult ;
  RobotRaconteur::EnumDefinitionValue *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::EnumDefinitionValue *)new RobotRaconteur::EnumDefinitionValue();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_EnumDefinitionValue_Name_set(void * jarg1, char * jarg2) {
  RobotRaconteur::EnumDefinitionValue *arg1 = (RobotRaconteur::EnumDefinitionValue *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::EnumDefinitionValue *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->Name = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_EnumDefinitionValue_Name_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::EnumDefinitionValue *arg1 = (RobotRaconteur::EnumDefinitionValue *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (RobotRaconteur::EnumDefinitionValue *)jarg1; 
  result = (std::string *) & ((arg1)->Name);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_EnumDefinitionValue_DocString_set(void * jarg1, char * jarg2) {
  RobotRaconteur::EnumDefinitionValue *arg1 = (RobotRaconteur::EnumDefinitionValue *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::EnumDefinitionValue *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->DocString = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_EnumDefinitionValue_DocString_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::EnumDefinitionValue *arg1 = (RobotRaconteur::EnumDefinitionValue *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (RobotRaconteur::EnumDefinitionValue *)jarg1; 
  result = (std::string *) & ((arg1)->DocString);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_EnumDefinitionValue_Value_set(void * jarg1, int jarg2) {
  RobotRaconteur::EnumDefinitionValue *arg1 = (RobotRaconteur::EnumDefinitionValue *) 0 ;
  int32_t arg2 ;
  
  arg1 = (RobotRaconteur::EnumDefinitionValue *)jarg1; 
  arg2 = (int32_t)jarg2; 
  if (arg1) (arg1)->Value = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_EnumDefinitionValue_Value_get(void * jarg1) {
  int jresult ;
  RobotRaconteur::EnumDefinitionValue *arg1 = (RobotRaconteur::EnumDefinitionValue *) 0 ;
  int32_t result;
  
  arg1 = (RobotRaconteur::EnumDefinitionValue *)jarg1; 
  result = (int32_t) ((arg1)->Value);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_EnumDefinitionValue_ImplicitValue_set(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::EnumDefinitionValue *arg1 = (RobotRaconteur::EnumDefinitionValue *) 0 ;
  bool arg2 ;
  
  arg1 = (RobotRaconteur::EnumDefinitionValue *)jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->ImplicitValue = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_EnumDefinitionValue_ImplicitValue_get(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::EnumDefinitionValue *arg1 = (RobotRaconteur::EnumDefinitionValue *) 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::EnumDefinitionValue *)jarg1; 
  result = (bool) ((arg1)->ImplicitValue);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_EnumDefinitionValue_HexValue_set(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::EnumDefinitionValue *arg1 = (RobotRaconteur::EnumDefinitionValue *) 0 ;
  bool arg2 ;
  
  arg1 = (RobotRaconteur::EnumDefinitionValue *)jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->HexValue = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_EnumDefinitionValue_HexValue_get(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::EnumDefinitionValue *arg1 = (RobotRaconteur::EnumDefinitionValue *) 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::EnumDefinitionValue *)jarg1; 
  result = (bool) ((arg1)->HexValue);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_EnumDefinitionValue(void * jarg1) {
  RobotRaconteur::EnumDefinitionValue *arg1 = (RobotRaconteur::EnumDefinitionValue *) 0 ;
  
  arg1 = (RobotRaconteur::EnumDefinitionValue *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_ExceptionDefinition(void * jarg1) {
  RobotRaconteur::ExceptionDefinition *arg1 = (RobotRaconteur::ExceptionDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ExceptionDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ExceptionDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ExceptionDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ExceptionDefinition_Name_set(void * jarg1, char * jarg2) {
  RobotRaconteur::ExceptionDefinition *arg1 = (RobotRaconteur::ExceptionDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::ExceptionDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ExceptionDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ExceptionDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->Name = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ExceptionDefinition_Name_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::ExceptionDefinition *arg1 = (RobotRaconteur::ExceptionDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ExceptionDefinition > *smartarg1 = 0 ;
  std::string *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ExceptionDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ExceptionDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::string *) & ((arg1)->Name);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ExceptionDefinition_DocString_set(void * jarg1, char * jarg2) {
  RobotRaconteur::ExceptionDefinition *arg1 = (RobotRaconteur::ExceptionDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::ExceptionDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ExceptionDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ExceptionDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->DocString = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ExceptionDefinition_DocString_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::ExceptionDefinition *arg1 = (RobotRaconteur::ExceptionDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ExceptionDefinition > *smartarg1 = 0 ;
  std::string *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ExceptionDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ExceptionDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::string *) & ((arg1)->DocString);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ExceptionDefinition_ParseInfo_set(void * jarg1, void * jarg2) {
  RobotRaconteur::ExceptionDefinition *arg1 = (RobotRaconteur::ExceptionDefinition *) 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *arg2 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  boost::shared_ptr< RobotRaconteur::ExceptionDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ExceptionDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ExceptionDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg2; 
  if (arg1) (arg1)->ParseInfo = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ExceptionDefinition_ParseInfo_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ExceptionDefinition *arg1 = (RobotRaconteur::ExceptionDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ExceptionDefinition > *smartarg1 = 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ExceptionDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ExceptionDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  result = (RobotRaconteur::ServiceDefinitionParseInfo *)& ((arg1)->ParseInfo);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ExceptionDefinition__GetService(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ExceptionDefinition *arg1 = (RobotRaconteur::ExceptionDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ExceptionDefinition > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ExceptionDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ExceptionDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = RobotRaconteur_ExceptionDefinition_GetService(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::ServiceDefinition >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ExceptionDefinition__SetService(void * jarg1, void * jarg2) {
  RobotRaconteur::ExceptionDefinition *arg1 = (RobotRaconteur::ExceptionDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::ExceptionDefinition > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ExceptionDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ExceptionDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::ServiceDefinition > *)jarg2 : &tempnull2; 
  
  try {
    RobotRaconteur_ExceptionDefinition_SetService(arg1,(boost::shared_ptr< RobotRaconteur::ServiceDefinition > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_ExceptionDefinition(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > tempnull1 ;
  RobotRaconteur::ExceptionDefinition *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::ServiceDefinition > *)jarg1 : &tempnull1; 
  
  try {
    result = (RobotRaconteur::ExceptionDefinition *)new RobotRaconteur::ExceptionDefinition((boost::shared_ptr< RobotRaconteur::ServiceDefinition > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::ExceptionDefinition >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ExceptionDefinition_ToString(void * jarg1) {
  char * jresult ;
  RobotRaconteur::ExceptionDefinition *arg1 = (RobotRaconteur::ExceptionDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ExceptionDefinition > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ExceptionDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ExceptionDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->ToString();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ExceptionDefinition_FromString__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
  RobotRaconteur::ExceptionDefinition *arg1 = (RobotRaconteur::ExceptionDefinition *) 0 ;
  std::string *arg2 = 0 ;
  RobotRaconteur::ServiceDefinitionParseInfo *arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *) 0 ;
  boost::shared_ptr< RobotRaconteur::ExceptionDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ExceptionDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ExceptionDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (RobotRaconteur::ServiceDefinitionParseInfo *)jarg3; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2,(RobotRaconteur::ServiceDefinitionParseInfo const *)arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ExceptionDefinition_FromString__SWIG_1(void * jarg1, char * jarg2) {
  RobotRaconteur::ExceptionDefinition *arg1 = (RobotRaconteur::ExceptionDefinition *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::ExceptionDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ExceptionDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ExceptionDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->FromString((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ExceptionDefinition_Reset(void * jarg1) {
  RobotRaconteur::ExceptionDefinition *arg1 = (RobotRaconteur::ExceptionDefinition *) 0 ;
  boost::shared_ptr< RobotRaconteur::ExceptionDefinition > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ExceptionDefinition > *)jarg1;
  arg1 = (RobotRaconteur::ExceptionDefinition *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->Reset();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MemberDefinitionUtil_ToProperty(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > tempnull1 ;
  boost::shared_ptr< RobotRaconteur::PropertyDefinition > result;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::MemberDefinition > *)jarg1 : &tempnull1; 
  
  try {
    result = MemberDefinitionUtil::ToProperty((boost::shared_ptr< RobotRaconteur::MemberDefinition > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::PropertyDefinition >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MemberDefinitionUtil_ToFunction(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > tempnull1 ;
  boost::shared_ptr< RobotRaconteur::FunctionDefinition > result;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::MemberDefinition > *)jarg1 : &tempnull1; 
  
  try {
    result = MemberDefinitionUtil::ToFunction((boost::shared_ptr< RobotRaconteur::MemberDefinition > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::FunctionDefinition >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MemberDefinitionUtil_ToObjRef(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > tempnull1 ;
  boost::shared_ptr< RobotRaconteur::ObjRefDefinition > result;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::MemberDefinition > *)jarg1 : &tempnull1; 
  
  try {
    result = MemberDefinitionUtil::ToObjRef((boost::shared_ptr< RobotRaconteur::MemberDefinition > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::ObjRefDefinition >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MemberDefinitionUtil_ToEvent(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > tempnull1 ;
  boost::shared_ptr< RobotRaconteur::EventDefinition > result;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::MemberDefinition > *)jarg1 : &tempnull1; 
  
  try {
    result = MemberDefinitionUtil::ToEvent((boost::shared_ptr< RobotRaconteur::MemberDefinition > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::EventDefinition >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MemberDefinitionUtil_ToPipe(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > tempnull1 ;
  boost::shared_ptr< RobotRaconteur::PipeDefinition > result;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::MemberDefinition > *)jarg1 : &tempnull1; 
  
  try {
    result = MemberDefinitionUtil::ToPipe((boost::shared_ptr< RobotRaconteur::MemberDefinition > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::PipeDefinition >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MemberDefinitionUtil_ToCallback(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > tempnull1 ;
  boost::shared_ptr< RobotRaconteur::CallbackDefinition > result;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::MemberDefinition > *)jarg1 : &tempnull1; 
  
  try {
    result = MemberDefinitionUtil::ToCallback((boost::shared_ptr< RobotRaconteur::MemberDefinition > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::CallbackDefinition >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MemberDefinitionUtil_ToWire(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > tempnull1 ;
  boost::shared_ptr< RobotRaconteur::WireDefinition > result;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::MemberDefinition > *)jarg1 : &tempnull1; 
  
  try {
    result = MemberDefinitionUtil::ToWire((boost::shared_ptr< RobotRaconteur::MemberDefinition > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WireDefinition >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MemberDefinitionUtil_ToMemory(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::MemberDefinition > tempnull1 ;
  boost::shared_ptr< RobotRaconteur::MemoryDefinition > result;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::MemberDefinition > *)jarg1 : &tempnull1; 
  
  try {
    result = MemberDefinitionUtil::ToMemory((boost::shared_ptr< RobotRaconteur::MemberDefinition > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::MemoryDefinition >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_MemberDefinitionUtil() {
  void * jresult ;
  MemberDefinitionUtil *result = 0 ;
  
  
  try {
    result = (MemberDefinitionUtil *)new MemberDefinitionUtil();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_MemberDefinitionUtil(void * jarg1) {
  MemberDefinitionUtil *arg1 = (MemberDefinitionUtil *) 0 ;
  
  arg1 = (MemberDefinitionUtil *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_NodeID__SWIG_0() {
  void * jresult ;
  RobotRaconteur::NodeID *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::NodeID *)new RobotRaconteur::NodeID();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_NodeID_ToString__SWIG_0(void * jarg1) {
  char * jresult ;
  RobotRaconteur::NodeID *arg1 = (RobotRaconteur::NodeID *) 0 ;
  std::string result;
  
  arg1 = (RobotRaconteur::NodeID *)jarg1; 
  
  try {
    result = ((RobotRaconteur::NodeID const *)arg1)->ToString();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_NodeID_ToString__SWIG_1(void * jarg1, char * jarg2) {
  char * jresult ;
  RobotRaconteur::NodeID *arg1 = (RobotRaconteur::NodeID *) 0 ;
  std::string *arg2 = 0 ;
  std::string result;
  
  arg1 = (RobotRaconteur::NodeID *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = ((RobotRaconteur::NodeID const *)arg1)->ToString((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_NodeID_NewUniqueID() {
  void * jresult ;
  RobotRaconteur::NodeID result;
  
  
  try {
    result = RobotRaconteur::NodeID::NewUniqueID();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::NodeID((const RobotRaconteur::NodeID &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_NodeID_eq(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::NodeID *arg1 = (RobotRaconteur::NodeID *) 0 ;
  RobotRaconteur::NodeID *arg2 = 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::NodeID *)jarg1; 
  arg2 = (RobotRaconteur::NodeID *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::NodeID const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)((RobotRaconteur::NodeID const *)arg1)->operator ==((RobotRaconteur::NodeID const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_NodeID_ne(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::NodeID *arg1 = (RobotRaconteur::NodeID *) 0 ;
  RobotRaconteur::NodeID *arg2 = 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::NodeID *)jarg1; 
  arg2 = (RobotRaconteur::NodeID *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::NodeID const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)((RobotRaconteur::NodeID const *)arg1)->operator !=((RobotRaconteur::NodeID const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_NodeID_lt(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::NodeID *arg1 = (RobotRaconteur::NodeID *) 0 ;
  RobotRaconteur::NodeID *arg2 = 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::NodeID *)jarg1; 
  arg2 = (RobotRaconteur::NodeID *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::NodeID const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)((RobotRaconteur::NodeID const *)arg1)->operator <((RobotRaconteur::NodeID const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_NodeID_IsAnyNode(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::NodeID *arg1 = (RobotRaconteur::NodeID *) 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::NodeID *)jarg1; 
  
  try {
    result = (bool)(arg1)->IsAnyNode();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_NodeID_GetAny() {
  void * jresult ;
  RobotRaconteur::NodeID result;
  
  
  try {
    result = RobotRaconteur::NodeID::GetAny();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::NodeID((const RobotRaconteur::NodeID &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_NodeID__SWIG_1(char * jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  RobotRaconteur::NodeID *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  
  try {
    result = (RobotRaconteur::NodeID *)new RobotRaconteur::NodeID((std::string const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_NodeID__SWIG_2(void * jarg1) {
  void * jresult ;
  RobotRaconteur::NodeID *arg1 = 0 ;
  RobotRaconteur::NodeID *result = 0 ;
  
  arg1 = (RobotRaconteur::NodeID *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::NodeID const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (RobotRaconteur::NodeID *)new RobotRaconteur::NodeID((RobotRaconteur::NodeID const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_NodeID__SWIG_3(unsigned char* jarg1, int jarg2) {
  void * jresult ;
  uint8_t *arg1 ;
  int32_t arg2 ;
  RobotRaconteur::NodeID *result = 0 ;
  
  arg1 = jarg1;
  arg2 = (int32_t)jarg2; 
  
  try {
    result = (RobotRaconteur::NodeID *)new_RobotRaconteur_NodeID__SWIG_3((unsigned char const (*))arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_NodeID_ToByteArrayC(void * jarg1, unsigned char* jarg2) {
  RobotRaconteur::NodeID *arg1 = (RobotRaconteur::NodeID *) 0 ;
  uint8_t *arg2 ;
  
  arg1 = (RobotRaconteur::NodeID *)jarg1; 
  arg2 = jarg2;
  
  try {
    RobotRaconteur_NodeID_ToByteArray(arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
  
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_NodeID(void * jarg1) {
  RobotRaconteur::NodeID *arg1 = (RobotRaconteur::NodeID *) 0 ;
  
  arg1 = (RobotRaconteur::NodeID *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageentry_Clear(void * jarg1) {
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *) 0 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *)jarg1; 
  
  try {
    (arg1)->clear();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageentry_Add(void * jarg1, void * jarg2) {
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageEntry > *arg2 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageEntry > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageEntry > temp2 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg2 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *)jarg1; 
  
  // intrusive_ptr by reference
  if ( jarg2 ) {
    smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry >**)&jarg2;
    temp2 = boost::intrusive_ptr<  RobotRaconteur::MessageEntry >(smartarg2->get(), true);
    arg2 = &temp2;
  } else {
    arg2 = &tempnull2;
  }
  
  
  try {
    (arg1)->push_back((boost::intrusive_ptr< RobotRaconteur::MessageEntry > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageentry_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *) 0 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > >::size_type result;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *)jarg1; 
  
  try {
    result = ((std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > const *)arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageentry_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *) 0 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > >::size_type result;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *)jarg1; 
  
  try {
    result = ((std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > const *)arg1)->capacity();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageentry_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *) 0 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > >::size_type arg2 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *)jarg1; 
  arg2 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > >::size_type)jarg2; 
  
  try {
    (arg1)->reserve(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_messageentry__SWIG_0() {
  void * jresult ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *result = 0 ;
  
  
  try {
    result = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *)new std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > >();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_messageentry__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *arg1 = 0 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *result = 0 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *)new std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > >((std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_messageentry__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  
  try {
    try {
      result = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *)new_std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageEntry_Sg__Sg___SWIG_2(arg1);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageentry_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *) 0 ;
  int arg2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageEntry > result;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageEntry_Sg__Sg__getitemcopy(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageEntry >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageEntry >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageentry_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *) 0 ;
  int arg2 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > >::value_type *result = 0 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > >::value_type *) &std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageEntry_Sg__Sg__getitem(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (*result) {
    intrusive_ptr_add_ref(result->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageEntry >(result->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageEntry >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageentry_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *) 0 ;
  int arg2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageEntry > *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageEntry > tempnull3 ;
  boost::intrusive_ptr< RobotRaconteur::MessageEntry > temp3 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg3 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  // intrusive_ptr by reference
  if ( jarg3 ) {
    smartarg3 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry >**)&jarg3;
    temp3 = boost::intrusive_ptr<  RobotRaconteur::MessageEntry >(smartarg3->get(), true);
    arg3 = &temp3;
  } else {
    arg3 = &tempnull3;
  }
  
  
  try {
    try {
      std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageEntry_Sg__Sg__setitem(arg1,arg2,(boost::intrusive_ptr< RobotRaconteur::MessageEntry > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageentry_AddRange(void * jarg1, void * jarg2) {
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *) 0 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *)jarg1; 
  arg2 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > const & type is null", 0);
    return ;
  } 
  
  try {
    std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageEntry_Sg__Sg__AddRange(arg1,(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageentry_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *result = 0 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      result = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *)std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageEntry_Sg__Sg__GetRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageentry_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *) 0 ;
  int arg2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageEntry > *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageEntry > tempnull3 ;
  boost::intrusive_ptr< RobotRaconteur::MessageEntry > temp3 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg3 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  // intrusive_ptr by reference
  if ( jarg3 ) {
    smartarg3 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry >**)&jarg3;
    temp3 = boost::intrusive_ptr<  RobotRaconteur::MessageEntry >(smartarg3->get(), true);
    arg3 = &temp3;
  } else {
    arg3 = &tempnull3;
  }
  
  
  try {
    try {
      std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageEntry_Sg__Sg__Insert(arg1,arg2,(boost::intrusive_ptr< RobotRaconteur::MessageEntry > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageentry_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *) 0 ;
  int arg2 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageEntry_Sg__Sg__InsertRange(arg1,arg2,(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageentry_RemoveAt(void * jarg1, int jarg2) {
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageEntry_Sg__Sg__RemoveAt(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageentry_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageEntry_Sg__Sg__RemoveRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageentry_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  boost::intrusive_ptr< RobotRaconteur::MessageEntry > *arg1 = 0 ;
  int arg2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageEntry > tempnull1 ;
  boost::intrusive_ptr< RobotRaconteur::MessageEntry > temp1 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg1 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *result = 0 ;
  
  
  // intrusive_ptr by reference
  if ( jarg1 ) {
    smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry >**)&jarg1;
    temp1 = boost::intrusive_ptr<  RobotRaconteur::MessageEntry >(smartarg1->get(), true);
    arg1 = &temp1;
  } else {
    arg1 = &tempnull1;
  }
  
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *)std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageEntry_Sg__Sg__Repeat((boost::intrusive_ptr< RobotRaconteur::MessageEntry > const &)*arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageentry_Reverse__SWIG_0(void * jarg1) {
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *) 0 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *)jarg1; 
  
  try {
    std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageEntry_Sg__Sg__Reverse__SWIG_0(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageentry_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageEntry_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageentry_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *) 0 ;
  int arg2 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageEntry_Sg__Sg__SetRange(arg1,arg2,(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_vectorptr_messageentry(void * jarg1) {
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *) 0 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageelement_Clear(void * jarg1) {
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *) 0 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg1; 
  
  try {
    (arg1)->clear();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageelement_Add(void * jarg1, void * jarg2) {
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *arg2 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > temp2 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg2 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg1; 
  
  // intrusive_ptr by reference
  if ( jarg2 ) {
    smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg2;
    temp2 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg2->get(), true);
    arg2 = &temp2;
  } else {
    arg2 = &tempnull2;
  }
  
  
  try {
    (arg1)->push_back((boost::intrusive_ptr< RobotRaconteur::MessageElement > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageelement_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *) 0 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > >::size_type result;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg1; 
  
  try {
    result = ((std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > const *)arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageelement_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *) 0 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > >::size_type result;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg1; 
  
  try {
    result = ((std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > const *)arg1)->capacity();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageelement_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *) 0 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > >::size_type arg2 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg1; 
  arg2 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > >::size_type)jarg2; 
  
  try {
    (arg1)->reserve(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_messageelement__SWIG_0() {
  void * jresult ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *result = 0 ;
  
  
  try {
    result = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)new std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > >();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_messageelement__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg1 = 0 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *result = 0 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)new std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > >((std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_messageelement__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  
  try {
    try {
      result = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)new_std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageElement_Sg__Sg___SWIG_2(arg1);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageelement_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *) 0 ;
  int arg2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > result;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageElement_Sg__Sg__getitemcopy(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageelement_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *) 0 ;
  int arg2 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > >::value_type *result = 0 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > >::value_type *) &std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageElement_Sg__Sg__getitem(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (*result) {
    intrusive_ptr_add_ref(result->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >(result->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageelement_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *) 0 ;
  int arg2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > tempnull3 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > temp3 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg3 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  // intrusive_ptr by reference
  if ( jarg3 ) {
    smartarg3 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg3;
    temp3 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg3->get(), true);
    arg3 = &temp3;
  } else {
    arg3 = &tempnull3;
  }
  
  
  try {
    try {
      std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageElement_Sg__Sg__setitem(arg1,arg2,(boost::intrusive_ptr< RobotRaconteur::MessageElement > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageelement_AddRange(void * jarg1, void * jarg2) {
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *) 0 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg1; 
  arg2 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > const & type is null", 0);
    return ;
  } 
  
  try {
    std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageElement_Sg__Sg__AddRange(arg1,(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageelement_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *result = 0 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      result = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageElement_Sg__Sg__GetRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageelement_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *) 0 ;
  int arg2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > tempnull3 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > temp3 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg3 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  // intrusive_ptr by reference
  if ( jarg3 ) {
    smartarg3 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg3;
    temp3 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg3->get(), true);
    arg3 = &temp3;
  } else {
    arg3 = &tempnull3;
  }
  
  
  try {
    try {
      std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageElement_Sg__Sg__Insert(arg1,arg2,(boost::intrusive_ptr< RobotRaconteur::MessageElement > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageelement_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *) 0 ;
  int arg2 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageElement_Sg__Sg__InsertRange(arg1,arg2,(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageelement_RemoveAt(void * jarg1, int jarg2) {
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageElement_Sg__Sg__RemoveAt(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageelement_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageElement_Sg__Sg__RemoveRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageelement_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *arg1 = 0 ;
  int arg2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > tempnull1 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > temp1 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg1 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *result = 0 ;
  
  
  // intrusive_ptr by reference
  if ( jarg1 ) {
    smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg1;
    temp1 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg1->get(), true);
    arg1 = &temp1;
  } else {
    arg1 = &tempnull1;
  }
  
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageElement_Sg__Sg__Repeat((boost::intrusive_ptr< RobotRaconteur::MessageElement > const &)*arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageelement_Reverse__SWIG_0(void * jarg1) {
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *) 0 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg1; 
  
  try {
    std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageElement_Sg__Sg__Reverse__SWIG_0(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageelement_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageElement_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_messageelement_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *) 0 ;
  int arg2 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_boost_intrusive_ptr_Sl_RobotRaconteur_MessageElement_Sg__Sg__SetRange(arg1,arg2,(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_vectorptr_messageelement(void * jarg1) {
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *) 0 ;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_Message_header_set(void * jarg1, void * jarg2) {
  RobotRaconteur::Message *arg1 = (RobotRaconteur::Message *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageHeader > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::Message > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageHeader > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageHeader > temp2 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg2 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::Message > **)&jarg1;
  arg1 = (RobotRaconteur::Message *)(smartarg1 ? smartarg1->get() : 0);
  
  
  // intrusive_ptr by reference
  if ( jarg2 ) {
    smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader >**)&jarg2;
    temp2 = boost::intrusive_ptr<  RobotRaconteur::MessageHeader >(smartarg2->get(), true);
    arg2 = &temp2;
  } else {
    arg2 = &tempnull2;
  }
  
  if (arg1) (arg1)->header = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_Message_header_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::Message *arg1 = (RobotRaconteur::Message *) 0 ;
  boost::shared_ptr< RobotRaconteur::Message > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageHeader > *result = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::Message > **)&jarg1;
  arg1 = (RobotRaconteur::Message *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (boost::intrusive_ptr< RobotRaconteur::MessageHeader > *) & ((arg1)->header);
  
  if (*result) {
    intrusive_ptr_add_ref(result->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageHeader >(result->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageHeader >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_Message_entries_set(void * jarg1, void * jarg2) {
  RobotRaconteur::Message *arg1 = (RobotRaconteur::Message *) 0 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *arg2 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *) 0 ;
  boost::shared_ptr< RobotRaconteur::Message > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::Message > **)&jarg1;
  arg1 = (RobotRaconteur::Message *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *)jarg2; 
  if (arg1) (arg1)->entries = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_Message_entries_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::Message *arg1 = (RobotRaconteur::Message *) 0 ;
  boost::shared_ptr< RobotRaconteur::Message > *smartarg1 = 0 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *result = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::Message > **)&jarg1;
  arg1 = (RobotRaconteur::Message *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageEntry > > *)& ((arg1)->entries);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_Message() {
  void * jresult ;
  RobotRaconteur::Message *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::Message *)new RobotRaconteur::Message();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  //plain pointer(out)
#if (1)
  if (result) {
    intrusive_ptr_add_ref(result);
    *(boost::shared_ptr<  RobotRaconteur::Message > **)&jresult = new boost::shared_ptr<  RobotRaconteur::Message >(result, SWIG_intrusive_deleter<  RobotRaconteur::Message >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::Message > **)&jresult = 0;
  }
#else
  *(boost::shared_ptr<  RobotRaconteur::Message > **)&jresult = result ? new boost::shared_ptr<  RobotRaconteur::Message >(result SWIG_NO_NULL_DELETER_0) : 0;
#endif
  
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_Message_ComputeSize(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::Message *arg1 = (RobotRaconteur::Message *) 0 ;
  boost::shared_ptr< RobotRaconteur::Message > *smartarg1 = 0 ;
  uint32_t result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::Message > **)&jarg1;
  arg1 = (RobotRaconteur::Message *)(smartarg1 ? smartarg1->get() : 0);
  
  
  try {
    result = (uint32_t)(arg1)->ComputeSize();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_Message_FindEntry(void * jarg1, char * jarg2) {
  void * jresult ;
  RobotRaconteur::Message *arg1 = (RobotRaconteur::Message *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::Message > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageEntry > result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::Message > **)&jarg1;
  arg1 = (RobotRaconteur::Message *)(smartarg1 ? smartarg1->get() : 0);
  
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (arg1)->FindEntry((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageEntry >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageEntry >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_Message_AddEntry(void * jarg1, int jarg2, char * jarg3) {
  void * jresult ;
  RobotRaconteur::Message *arg1 = (RobotRaconteur::Message *) 0 ;
  RobotRaconteur::MessageEntryType arg2 ;
  std::string *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::Message > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageEntry > result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::Message > **)&jarg1;
  arg1 = (RobotRaconteur::Message *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (RobotRaconteur::MessageEntryType)jarg2; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  try {
    result = (arg1)->AddEntry(arg2,(std::string const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageEntry >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageEntry >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_Message(void * jarg1) {
  RobotRaconteur::Message *arg1 = (RobotRaconteur::Message *) 0 ;
  boost::shared_ptr< RobotRaconteur::Message > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::Message > **)&jarg1;
  arg1 = (RobotRaconteur::Message *)(smartarg1 ? smartarg1->get() : 0);
  
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_HeaderSize_set(void * jarg1, unsigned short jarg2) {
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  uint16_t arg2 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (uint16_t)jarg2; 
  if (arg1) (arg1)->HeaderSize = arg2;
}


SWIGEXPORT unsigned short SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_HeaderSize_get(void * jarg1) {
  unsigned short jresult ;
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  uint16_t result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (uint16_t) ((arg1)->HeaderSize);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_MessageFlags_set(void * jarg1, unsigned char jarg2) {
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  uint8_t arg2 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (uint8_t)jarg2; 
  if (arg1) (arg1)->MessageFlags = arg2;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_MessageFlags_get(void * jarg1) {
  unsigned char jresult ;
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  uint8_t result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (uint8_t) ((arg1)->MessageFlags);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_SenderEndpoint_set(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  uint32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (uint32_t)jarg2; 
  if (arg1) (arg1)->SenderEndpoint = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_SenderEndpoint_get(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  uint32_t result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (uint32_t) ((arg1)->SenderEndpoint);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_ReceiverEndpoint_set(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  uint32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (uint32_t)jarg2; 
  if (arg1) (arg1)->ReceiverEndpoint = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_ReceiverEndpoint_get(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  uint32_t result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (uint32_t) ((arg1)->ReceiverEndpoint);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_SenderNodeName_set(void * jarg1, char * jarg2) {
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  RobotRaconteur::MessageStringPtr *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  RobotRaconteur::MessageStringPtr arg2_str(jarg2,false);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->SenderNodeName = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_SenderNodeName_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  RobotRaconteur::MessageStringPtr *result = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (RobotRaconteur::MessageStringPtr *) & ((arg1)->SenderNodeName);
  std::string temp_ret1 = result->str().to_string(); jresult = SWIG_csharp_string_callback(temp_ret1.c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_ReceiverNodeName_set(void * jarg1, char * jarg2) {
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  RobotRaconteur::MessageStringPtr *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  RobotRaconteur::MessageStringPtr arg2_str(jarg2,false);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->ReceiverNodeName = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_ReceiverNodeName_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  RobotRaconteur::MessageStringPtr *result = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (RobotRaconteur::MessageStringPtr *) & ((arg1)->ReceiverNodeName);
  std::string temp_ret1 = result->str().to_string(); jresult = SWIG_csharp_string_callback(temp_ret1.c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_SenderNodeID_set(void * jarg1, void * jarg2) {
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  RobotRaconteur::NodeID *arg2 = (RobotRaconteur::NodeID *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (RobotRaconteur::NodeID *)jarg2; 
  if (arg1) (arg1)->SenderNodeID = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_SenderNodeID_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  RobotRaconteur::NodeID *result = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (RobotRaconteur::NodeID *)& ((arg1)->SenderNodeID);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_ReceiverNodeID_set(void * jarg1, void * jarg2) {
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  RobotRaconteur::NodeID *arg2 = (RobotRaconteur::NodeID *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (RobotRaconteur::NodeID *)jarg2; 
  if (arg1) (arg1)->ReceiverNodeID = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_ReceiverNodeID_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  RobotRaconteur::NodeID *result = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (RobotRaconteur::NodeID *)& ((arg1)->ReceiverNodeID);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_MetaData_set(void * jarg1, char * jarg2) {
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  RobotRaconteur::MessageStringPtr *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  RobotRaconteur::MessageStringPtr arg2_str(jarg2,false);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->MetaData = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_MetaData_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  RobotRaconteur::MessageStringPtr *result = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (RobotRaconteur::MessageStringPtr *) & ((arg1)->MetaData);
  std::string temp_ret1 = result->str().to_string(); jresult = SWIG_csharp_string_callback(temp_ret1.c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_EntryCount_set(void * jarg1, unsigned short jarg2) {
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  uint16_t arg2 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (uint16_t)jarg2; 
  if (arg1) (arg1)->EntryCount = arg2;
}


SWIGEXPORT unsigned short SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_EntryCount_get(void * jarg1) {
  unsigned short jresult ;
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  uint16_t result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (uint16_t) ((arg1)->EntryCount);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_MessageID_set(void * jarg1, unsigned short jarg2) {
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  uint16_t arg2 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (uint16_t)jarg2; 
  if (arg1) (arg1)->MessageID = arg2;
}


SWIGEXPORT unsigned short SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_MessageID_get(void * jarg1) {
  unsigned short jresult ;
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  uint16_t result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (uint16_t) ((arg1)->MessageID);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_MessageResID_set(void * jarg1, unsigned short jarg2) {
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  uint16_t arg2 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (uint16_t)jarg2; 
  if (arg1) (arg1)->MessageResID = arg2;
}


SWIGEXPORT unsigned short SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_MessageResID_get(void * jarg1) {
  unsigned short jresult ;
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  uint16_t result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (uint16_t) ((arg1)->MessageResID);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_MessageSize_set(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  uint32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (uint32_t)jarg2; 
  if (arg1) (arg1)->MessageSize = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_MessageSize_get(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  uint32_t result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (uint32_t) ((arg1)->MessageSize);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_Priority_set(void * jarg1, unsigned short jarg2) {
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  uint16_t arg2 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (uint16_t)jarg2; 
  if (arg1) (arg1)->Priority = arg2;
}


SWIGEXPORT unsigned short SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_Priority_get(void * jarg1) {
  unsigned short jresult ;
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  uint16_t result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (uint16_t) ((arg1)->Priority);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_Extended_set(void * jarg1, void * jarg2) {
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  std::vector< uint8_t > *arg2 = (std::vector< uint8_t > *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (std::vector< uint8_t > *)jarg2; 
  if (arg1) (arg1)->Extended = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_Extended_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  std::vector< uint8_t > *result = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (std::vector< uint8_t > *)& ((arg1)->Extended);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned short SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_ComputeSize(void * jarg1) {
  unsigned short jresult ;
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  uint16_t result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  
  try {
    result = (uint16_t)(arg1)->ComputeSize();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_UpdateHeader(void * jarg1, unsigned int jarg2, unsigned short jarg3) {
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  uint32_t arg2 ;
  uint16_t arg3 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (uint32_t)jarg2; 
  arg3 = (uint16_t)jarg3; 
  
  try {
    (arg1)->UpdateHeader(arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_MessageHeader() {
  void * jresult ;
  RobotRaconteur::MessageHeader *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::MessageHeader *)new RobotRaconteur::MessageHeader();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  //plain pointer(out)
#if (1)
  if (result) {
    intrusive_ptr_add_ref(result);
    *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageHeader >(result, SWIG_intrusive_deleter<  RobotRaconteur::MessageHeader >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jresult = 0;
  }
#else
  *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jresult = result ? new boost::shared_ptr<  RobotRaconteur::MessageHeader >(result SWIG_NO_NULL_DELETER_0) : 0;
#endif
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_MessageHeader(void * jarg1) {
  RobotRaconteur::MessageHeader *arg1 = (RobotRaconteur::MessageHeader *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageHeader > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageHeader > **)&jarg1;
  arg1 = (RobotRaconteur::MessageHeader *)(smartarg1 ? smartarg1->get() : 0);
  
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageEntry_EntrySize_set(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::MessageEntry *arg1 = (RobotRaconteur::MessageEntry *) 0 ;
  uint32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jarg1;
  arg1 = (RobotRaconteur::MessageEntry *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (uint32_t)jarg2; 
  if (arg1) (arg1)->EntrySize = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_MessageEntry_EntrySize_get(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::MessageEntry *arg1 = (RobotRaconteur::MessageEntry *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg1 = 0 ;
  uint32_t result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jarg1;
  arg1 = (RobotRaconteur::MessageEntry *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (uint32_t) ((arg1)->EntrySize);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageEntry_EntryFlags_set(void * jarg1, unsigned char jarg2) {
  RobotRaconteur::MessageEntry *arg1 = (RobotRaconteur::MessageEntry *) 0 ;
  uint8_t arg2 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jarg1;
  arg1 = (RobotRaconteur::MessageEntry *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (uint8_t)jarg2; 
  if (arg1) (arg1)->EntryFlags = arg2;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_MessageEntry_EntryFlags_get(void * jarg1) {
  unsigned char jresult ;
  RobotRaconteur::MessageEntry *arg1 = (RobotRaconteur::MessageEntry *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg1 = 0 ;
  uint8_t result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jarg1;
  arg1 = (RobotRaconteur::MessageEntry *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (uint8_t) ((arg1)->EntryFlags);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageEntry_EntryType_set(void * jarg1, int jarg2) {
  RobotRaconteur::MessageEntry *arg1 = (RobotRaconteur::MessageEntry *) 0 ;
  RobotRaconteur::MessageEntryType arg2 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jarg1;
  arg1 = (RobotRaconteur::MessageEntry *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (RobotRaconteur::MessageEntryType)jarg2; 
  if (arg1) (arg1)->EntryType = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_MessageEntry_EntryType_get(void * jarg1) {
  int jresult ;
  RobotRaconteur::MessageEntry *arg1 = (RobotRaconteur::MessageEntry *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg1 = 0 ;
  RobotRaconteur::MessageEntryType result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jarg1;
  arg1 = (RobotRaconteur::MessageEntry *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (RobotRaconteur::MessageEntryType) ((arg1)->EntryType);
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageEntry_ServicePath_set(void * jarg1, char * jarg2) {
  RobotRaconteur::MessageEntry *arg1 = (RobotRaconteur::MessageEntry *) 0 ;
  RobotRaconteur::MessageStringPtr *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jarg1;
  arg1 = (RobotRaconteur::MessageEntry *)(smartarg1 ? smartarg1->get() : 0);
  
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  RobotRaconteur::MessageStringPtr arg2_str(jarg2,false);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->ServicePath = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_MessageEntry_ServicePath_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::MessageEntry *arg1 = (RobotRaconteur::MessageEntry *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg1 = 0 ;
  RobotRaconteur::MessageStringPtr *result = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jarg1;
  arg1 = (RobotRaconteur::MessageEntry *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (RobotRaconteur::MessageStringPtr *) & ((arg1)->ServicePath);
  std::string temp_ret1 = result->str().to_string(); jresult = SWIG_csharp_string_callback(temp_ret1.c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageEntry_MemberName_set(void * jarg1, char * jarg2) {
  RobotRaconteur::MessageEntry *arg1 = (RobotRaconteur::MessageEntry *) 0 ;
  RobotRaconteur::MessageStringPtr *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jarg1;
  arg1 = (RobotRaconteur::MessageEntry *)(smartarg1 ? smartarg1->get() : 0);
  
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  RobotRaconteur::MessageStringPtr arg2_str(jarg2,false);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->MemberName = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_MessageEntry_MemberName_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::MessageEntry *arg1 = (RobotRaconteur::MessageEntry *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg1 = 0 ;
  RobotRaconteur::MessageStringPtr *result = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jarg1;
  arg1 = (RobotRaconteur::MessageEntry *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (RobotRaconteur::MessageStringPtr *) & ((arg1)->MemberName);
  std::string temp_ret1 = result->str().to_string(); jresult = SWIG_csharp_string_callback(temp_ret1.c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageEntry_MemberNameCode_set(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::MessageEntry *arg1 = (RobotRaconteur::MessageEntry *) 0 ;
  uint32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jarg1;
  arg1 = (RobotRaconteur::MessageEntry *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (uint32_t)jarg2; 
  if (arg1) (arg1)->MemberNameCode = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_MessageEntry_MemberNameCode_get(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::MessageEntry *arg1 = (RobotRaconteur::MessageEntry *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg1 = 0 ;
  uint32_t result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jarg1;
  arg1 = (RobotRaconteur::MessageEntry *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (uint32_t) ((arg1)->MemberNameCode);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageEntry_RequestID_set(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::MessageEntry *arg1 = (RobotRaconteur::MessageEntry *) 0 ;
  uint32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jarg1;
  arg1 = (RobotRaconteur::MessageEntry *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (uint32_t)jarg2; 
  if (arg1) (arg1)->RequestID = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_MessageEntry_RequestID_get(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::MessageEntry *arg1 = (RobotRaconteur::MessageEntry *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg1 = 0 ;
  uint32_t result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jarg1;
  arg1 = (RobotRaconteur::MessageEntry *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (uint32_t) ((arg1)->RequestID);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageEntry_Error_set(void * jarg1, int jarg2) {
  RobotRaconteur::MessageEntry *arg1 = (RobotRaconteur::MessageEntry *) 0 ;
  RobotRaconteur::MessageErrorType arg2 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jarg1;
  arg1 = (RobotRaconteur::MessageEntry *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (RobotRaconteur::MessageErrorType)jarg2; 
  if (arg1) (arg1)->Error = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_MessageEntry_Error_get(void * jarg1) {
  int jresult ;
  RobotRaconteur::MessageEntry *arg1 = (RobotRaconteur::MessageEntry *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg1 = 0 ;
  RobotRaconteur::MessageErrorType result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jarg1;
  arg1 = (RobotRaconteur::MessageEntry *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (RobotRaconteur::MessageErrorType) ((arg1)->Error);
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageEntry_MetaData_set(void * jarg1, char * jarg2) {
  RobotRaconteur::MessageEntry *arg1 = (RobotRaconteur::MessageEntry *) 0 ;
  RobotRaconteur::MessageStringPtr *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jarg1;
  arg1 = (RobotRaconteur::MessageEntry *)(smartarg1 ? smartarg1->get() : 0);
  
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  RobotRaconteur::MessageStringPtr arg2_str(jarg2,false);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->MetaData = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_MessageEntry_MetaData_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::MessageEntry *arg1 = (RobotRaconteur::MessageEntry *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg1 = 0 ;
  RobotRaconteur::MessageStringPtr *result = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jarg1;
  arg1 = (RobotRaconteur::MessageEntry *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (RobotRaconteur::MessageStringPtr *) & ((arg1)->MetaData);
  std::string temp_ret1 = result->str().to_string(); jresult = SWIG_csharp_string_callback(temp_ret1.c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageEntry_Extended_set(void * jarg1, void * jarg2) {
  RobotRaconteur::MessageEntry *arg1 = (RobotRaconteur::MessageEntry *) 0 ;
  std::vector< uint8_t > *arg2 = (std::vector< uint8_t > *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jarg1;
  arg1 = (RobotRaconteur::MessageEntry *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (std::vector< uint8_t > *)jarg2; 
  if (arg1) (arg1)->Extended = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MessageEntry_Extended_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::MessageEntry *arg1 = (RobotRaconteur::MessageEntry *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg1 = 0 ;
  std::vector< uint8_t > *result = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jarg1;
  arg1 = (RobotRaconteur::MessageEntry *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (std::vector< uint8_t > *)& ((arg1)->Extended);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageEntry_elements_set(void * jarg1, void * jarg2) {
  RobotRaconteur::MessageEntry *arg1 = (RobotRaconteur::MessageEntry *) 0 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg2 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jarg1;
  arg1 = (RobotRaconteur::MessageEntry *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg2; 
  if (arg1) (arg1)->elements = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MessageEntry_elements_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::MessageEntry *arg1 = (RobotRaconteur::MessageEntry *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg1 = 0 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *result = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jarg1;
  arg1 = (RobotRaconteur::MessageEntry *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)& ((arg1)->elements);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_MessageEntry__SWIG_0() {
  void * jresult ;
  RobotRaconteur::MessageEntry *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::MessageEntry *)new RobotRaconteur::MessageEntry();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  //plain pointer(out)
#if (1)
  if (result) {
    intrusive_ptr_add_ref(result);
    *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageEntry >(result, SWIG_intrusive_deleter<  RobotRaconteur::MessageEntry >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jresult = 0;
  }
#else
  *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jresult = result ? new boost::shared_ptr<  RobotRaconteur::MessageEntry >(result SWIG_NO_NULL_DELETER_0) : 0;
#endif
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_MessageEntry__SWIG_1(int jarg1, char * jarg2) {
  void * jresult ;
  RobotRaconteur::MessageEntryType arg1 ;
  std::string *arg2 = 0 ;
  RobotRaconteur::MessageEntry *result = 0 ;
  
  arg1 = (RobotRaconteur::MessageEntryType)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (RobotRaconteur::MessageEntry *)new RobotRaconteur::MessageEntry(arg1,(std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  //plain pointer(out)
#if (1)
  if (result) {
    intrusive_ptr_add_ref(result);
    *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageEntry >(result, SWIG_intrusive_deleter<  RobotRaconteur::MessageEntry >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jresult = 0;
  }
#else
  *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jresult = result ? new boost::shared_ptr<  RobotRaconteur::MessageEntry >(result SWIG_NO_NULL_DELETER_0) : 0;
#endif
  
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_MessageEntry_ComputeSize(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::MessageEntry *arg1 = (RobotRaconteur::MessageEntry *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg1 = 0 ;
  uint32_t result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jarg1;
  arg1 = (RobotRaconteur::MessageEntry *)(smartarg1 ? smartarg1->get() : 0);
  
  
  try {
    result = (uint32_t)(arg1)->ComputeSize();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MessageEntry_FindElement(void * jarg1, char * jarg2) {
  void * jresult ;
  RobotRaconteur::MessageEntry *arg1 = (RobotRaconteur::MessageEntry *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jarg1;
  arg1 = (RobotRaconteur::MessageEntry *)(smartarg1 ? smartarg1->get() : 0);
  
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (arg1)->FindElement((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MessageEntry_AddElement(void * jarg1, void * jarg2) {
  void * jresult ;
  RobotRaconteur::MessageEntry *arg1 = (RobotRaconteur::MessageEntry *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > temp2 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jarg1;
  arg1 = (RobotRaconteur::MessageEntry *)(smartarg1 ? smartarg1->get() : 0);
  
  
  // intrusive_ptr by reference
  if ( jarg2 ) {
    smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg2;
    temp2 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg2->get(), true);
    arg2 = &temp2;
  } else {
    arg2 = &tempnull2;
  }
  
  
  try {
    result = (arg1)->AddElement((boost::intrusive_ptr< RobotRaconteur::MessageElement > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_MessageEntry(void * jarg1) {
  RobotRaconteur::MessageEntry *arg1 = (RobotRaconteur::MessageEntry *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageEntry > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageEntry > **)&jarg1;
  arg1 = (RobotRaconteur::MessageEntry *)(smartarg1 ? smartarg1->get() : 0);
  
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElement_ElementSize_set(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::MessageElement *arg1 = (RobotRaconteur::MessageElement *) 0 ;
  uint32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElement *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (uint32_t)jarg2; 
  if (arg1) (arg1)->ElementSize = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_MessageElement_ElementSize_get(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::MessageElement *arg1 = (RobotRaconteur::MessageElement *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg1 = 0 ;
  uint32_t result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElement *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (uint32_t) ((arg1)->ElementSize);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElement_ElementFlags_set(void * jarg1, unsigned char jarg2) {
  RobotRaconteur::MessageElement *arg1 = (RobotRaconteur::MessageElement *) 0 ;
  uint8_t arg2 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElement *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (uint8_t)jarg2; 
  if (arg1) (arg1)->ElementFlags = arg2;
}


SWIGEXPORT unsigned char SWIGSTDCALL CSharp_RobotRaconteur_MessageElement_ElementFlags_get(void * jarg1) {
  unsigned char jresult ;
  RobotRaconteur::MessageElement *arg1 = (RobotRaconteur::MessageElement *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg1 = 0 ;
  uint8_t result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElement *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (uint8_t) ((arg1)->ElementFlags);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElement_ElementName_set(void * jarg1, char * jarg2) {
  RobotRaconteur::MessageElement *arg1 = (RobotRaconteur::MessageElement *) 0 ;
  RobotRaconteur::MessageStringPtr *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElement *)(smartarg1 ? smartarg1->get() : 0);
  
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  RobotRaconteur::MessageStringPtr arg2_str(jarg2,false);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->ElementName = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_MessageElement_ElementName_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::MessageElement *arg1 = (RobotRaconteur::MessageElement *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg1 = 0 ;
  RobotRaconteur::MessageStringPtr *result = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElement *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (RobotRaconteur::MessageStringPtr *) & ((arg1)->ElementName);
  std::string temp_ret1 = result->str().to_string(); jresult = SWIG_csharp_string_callback(temp_ret1.c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElement_ElementNameCode_set(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::MessageElement *arg1 = (RobotRaconteur::MessageElement *) 0 ;
  uint32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElement *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (uint32_t)jarg2; 
  if (arg1) (arg1)->ElementNameCode = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_MessageElement_ElementNameCode_get(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::MessageElement *arg1 = (RobotRaconteur::MessageElement *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg1 = 0 ;
  uint32_t result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElement *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (uint32_t) ((arg1)->ElementNameCode);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElement_ElementNumber_set(void * jarg1, int jarg2) {
  RobotRaconteur::MessageElement *arg1 = (RobotRaconteur::MessageElement *) 0 ;
  int32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElement *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (int32_t)jarg2; 
  if (arg1) (arg1)->ElementNumber = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_MessageElement_ElementNumber_get(void * jarg1) {
  int jresult ;
  RobotRaconteur::MessageElement *arg1 = (RobotRaconteur::MessageElement *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg1 = 0 ;
  int32_t result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElement *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (int32_t) ((arg1)->ElementNumber);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElement_ElementType_set(void * jarg1, int jarg2) {
  RobotRaconteur::MessageElement *arg1 = (RobotRaconteur::MessageElement *) 0 ;
  RobotRaconteur::DataTypes arg2 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElement *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (RobotRaconteur::DataTypes)jarg2; 
  if (arg1) (arg1)->ElementType = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_MessageElement_ElementType_get(void * jarg1) {
  int jresult ;
  RobotRaconteur::MessageElement *arg1 = (RobotRaconteur::MessageElement *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg1 = 0 ;
  RobotRaconteur::DataTypes result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElement *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (RobotRaconteur::DataTypes) ((arg1)->ElementType);
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElement_ElementTypeName_set(void * jarg1, char * jarg2) {
  RobotRaconteur::MessageElement *arg1 = (RobotRaconteur::MessageElement *) 0 ;
  RobotRaconteur::MessageStringPtr *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElement *)(smartarg1 ? smartarg1->get() : 0);
  
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  RobotRaconteur::MessageStringPtr arg2_str(jarg2,false);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->ElementTypeName = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_MessageElement_ElementTypeName_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::MessageElement *arg1 = (RobotRaconteur::MessageElement *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg1 = 0 ;
  RobotRaconteur::MessageStringPtr *result = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElement *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (RobotRaconteur::MessageStringPtr *) & ((arg1)->ElementTypeName);
  std::string temp_ret1 = result->str().to_string(); jresult = SWIG_csharp_string_callback(temp_ret1.c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElement_ElementTypeNameCode_set(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::MessageElement *arg1 = (RobotRaconteur::MessageElement *) 0 ;
  uint32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElement *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (uint32_t)jarg2; 
  if (arg1) (arg1)->ElementTypeNameCode = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_MessageElement_ElementTypeNameCode_get(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::MessageElement *arg1 = (RobotRaconteur::MessageElement *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg1 = 0 ;
  uint32_t result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElement *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (uint32_t) ((arg1)->ElementTypeNameCode);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElement_MetaData_set(void * jarg1, char * jarg2) {
  RobotRaconteur::MessageElement *arg1 = (RobotRaconteur::MessageElement *) 0 ;
  RobotRaconteur::MessageStringPtr *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElement *)(smartarg1 ? smartarg1->get() : 0);
  
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  RobotRaconteur::MessageStringPtr arg2_str(jarg2,false);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->MetaData = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_MessageElement_MetaData_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::MessageElement *arg1 = (RobotRaconteur::MessageElement *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg1 = 0 ;
  RobotRaconteur::MessageStringPtr *result = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElement *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (RobotRaconteur::MessageStringPtr *) & ((arg1)->MetaData);
  std::string temp_ret1 = result->str().to_string(); jresult = SWIG_csharp_string_callback(temp_ret1.c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElement_Extended_set(void * jarg1, void * jarg2) {
  RobotRaconteur::MessageElement *arg1 = (RobotRaconteur::MessageElement *) 0 ;
  std::vector< uint8_t > *arg2 = (std::vector< uint8_t > *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElement *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (std::vector< uint8_t > *)jarg2; 
  if (arg1) (arg1)->Extended = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MessageElement_Extended_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::MessageElement *arg1 = (RobotRaconteur::MessageElement *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg1 = 0 ;
  std::vector< uint8_t > *result = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElement *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (std::vector< uint8_t > *)& ((arg1)->Extended);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElement_DataCount_set(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::MessageElement *arg1 = (RobotRaconteur::MessageElement *) 0 ;
  uint32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElement *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (uint32_t)jarg2; 
  if (arg1) (arg1)->DataCount = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_MessageElement_DataCount_get(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::MessageElement *arg1 = (RobotRaconteur::MessageElement *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg1 = 0 ;
  uint32_t result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElement *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (uint32_t) ((arg1)->DataCount);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_MessageElement() {
  void * jresult ;
  RobotRaconteur::MessageElement *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::MessageElement *)new RobotRaconteur::MessageElement();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  //plain pointer(out)
#if (1)
  if (result) {
    intrusive_ptr_add_ref(result);
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >(result, SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
#else
  *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = result ? new boost::shared_ptr<  RobotRaconteur::MessageElement >(result SWIG_NO_NULL_DELETER_0) : 0;
#endif
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MessageElement__GetData(void * jarg1) {
  void * jresult ;
  RobotRaconteur::MessageElement *arg1 = (RobotRaconteur::MessageElement *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElement *)(smartarg1 ? smartarg1->get() : 0);
  
  
  try {
    result = (arg1)->GetData();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElementData > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElementData >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElementData >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElementData > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElement__SetData(void * jarg1, void * jarg2) {
  RobotRaconteur::MessageElement *arg1 = (RobotRaconteur::MessageElement *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > temp2 ;
  boost::shared_ptr< RobotRaconteur::MessageElementData > *smartarg2 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElement *)(smartarg1 ? smartarg1->get() : 0);
  
  
  // intrusive_ptr by reference
  if ( jarg2 ) {
    smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElementData >**)&jarg2;
    temp2 = boost::intrusive_ptr<  RobotRaconteur::MessageElementData >(smartarg2->get(), true);
    arg2 = &temp2;
  } else {
    arg2 = &tempnull2;
  }
  
  
  try {
    (arg1)->SetData((boost::intrusive_ptr< RobotRaconteur::MessageElementData > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_MessageElement_ComputeSize(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::MessageElement *arg1 = (RobotRaconteur::MessageElement *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg1 = 0 ;
  uint32_t result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElement *)(smartarg1 ? smartarg1->get() : 0);
  
  
  try {
    result = (uint32_t)(arg1)->ComputeSize();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElement_UpdateData(void * jarg1) {
  RobotRaconteur::MessageElement *arg1 = (RobotRaconteur::MessageElement *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElement *)(smartarg1 ? smartarg1->get() : 0);
  
  
  try {
    (arg1)->UpdateData();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MessageElement_FindElement(void * jarg1, char * jarg2) {
  void * jresult ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > result;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = RobotRaconteur::MessageElement::FindElement(*arg1,(std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_MessageElement_ContainsElement(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (bool)RobotRaconteur::MessageElement::ContainsElement(*arg1,(std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_MessageElement(void * jarg1) {
  RobotRaconteur::MessageElement *arg1 = (RobotRaconteur::MessageElement *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElement *)(smartarg1 ? smartarg1->get() : 0);
  
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementNestedElementList_Type_set(void * jarg1, int jarg2) {
  RobotRaconteur::MessageElementNestedElementList *arg1 = (RobotRaconteur::MessageElementNestedElementList *) 0 ;
  RobotRaconteur::DataTypes arg2 ;
  boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElementNestedElementList *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (RobotRaconteur::DataTypes)jarg2; 
  if (arg1) (arg1)->Type = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_MessageElementNestedElementList_Type_get(void * jarg1) {
  int jresult ;
  RobotRaconteur::MessageElementNestedElementList *arg1 = (RobotRaconteur::MessageElementNestedElementList *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > *smartarg1 = 0 ;
  RobotRaconteur::DataTypes result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElementNestedElementList *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (RobotRaconteur::DataTypes) ((arg1)->Type);
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementNestedElementList_TypeName_set(void * jarg1, char * jarg2) {
  RobotRaconteur::MessageElementNestedElementList *arg1 = (RobotRaconteur::MessageElementNestedElementList *) 0 ;
  RobotRaconteur::MessageStringPtr *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElementNestedElementList *)(smartarg1 ? smartarg1->get() : 0);
  
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  RobotRaconteur::MessageStringPtr arg2_str(jarg2,false);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->TypeName = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_MessageElementNestedElementList_TypeName_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::MessageElementNestedElementList *arg1 = (RobotRaconteur::MessageElementNestedElementList *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > *smartarg1 = 0 ;
  RobotRaconteur::MessageStringPtr *result = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElementNestedElementList *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (RobotRaconteur::MessageStringPtr *) & ((arg1)->TypeName);
  std::string temp_ret1 = result->str().to_string(); jresult = SWIG_csharp_string_callback(temp_ret1.c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementNestedElementList_Elements_set(void * jarg1, void * jarg2) {
  RobotRaconteur::MessageElementNestedElementList *arg1 = (RobotRaconteur::MessageElementNestedElementList *) 0 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg2 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElementNestedElementList *)(smartarg1 ? smartarg1->get() : 0);
  
  arg2 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg2; 
  if (arg1) (arg1)->Elements = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MessageElementNestedElementList_Elements_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::MessageElementNestedElementList *arg1 = (RobotRaconteur::MessageElementNestedElementList *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > *smartarg1 = 0 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *result = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElementNestedElementList *)(smartarg1 ? smartarg1->get() : 0);
  
  result = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)& ((arg1)->Elements);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_MessageElementNestedElementList(int jarg1, char * jarg2, void * jarg3) {
  void * jresult ;
  RobotRaconteur::DataTypes arg1 ;
  std::string *arg2 = 0 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg3 = 0 ;
  RobotRaconteur::MessageElementNestedElementList *result = 0 ;
  
  arg1 = (RobotRaconteur::DataTypes)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (RobotRaconteur::MessageElementNestedElementList *)new RobotRaconteur::MessageElementNestedElementList(arg1,(std::string const &)*arg2,(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  //plain pointer(out)
#if (1)
  if (result) {
    intrusive_ptr_add_ref(result);
    *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList >(result, SWIG_intrusive_deleter<  RobotRaconteur::MessageElementNestedElementList >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList > **)&jresult = 0;
  }
#else
  *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList > **)&jresult = result ? new boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList >(result SWIG_NO_NULL_DELETER_0) : 0;
#endif
  
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_MessageElementNestedElementList_GetTypeString(void * jarg1) {
  char * jresult ;
  RobotRaconteur::MessageElementNestedElementList *arg1 = (RobotRaconteur::MessageElementNestedElementList *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > *smartarg1 = 0 ;
  RobotRaconteur::MessageStringPtr result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElementNestedElementList *)(smartarg1 ? smartarg1->get() : 0);
  
  
  try {
    result = (arg1)->GetTypeString();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  std::string temp_ret1 = (&result)->str().to_string(); jresult = SWIG_csharp_string_callback(temp_ret1.c_str()); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_MessageElementNestedElementList_GetTypeID(void * jarg1) {
  int jresult ;
  RobotRaconteur::MessageElementNestedElementList *arg1 = (RobotRaconteur::MessageElementNestedElementList *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > *smartarg1 = 0 ;
  RobotRaconteur::DataTypes result;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElementNestedElementList *)(smartarg1 ? smartarg1->get() : 0);
  
  
  try {
    result = (RobotRaconteur::DataTypes)(arg1)->GetTypeID();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_MessageElementNestedElementList(void * jarg1) {
  RobotRaconteur::MessageElementNestedElementList *arg1 = (RobotRaconteur::MessageElementNestedElementList *) 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > *smartarg1 = 0 ;
  
  
  // plain pointer
  smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList > **)&jarg1;
  arg1 = (RobotRaconteur::MessageElementNestedElementList *)(smartarg1 ? smartarg1->get() : 0);
  
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_ToRRBaseArray(void * jarg1) {
  void * jresult ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > *arg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > tempnull1 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > temp1 ;
  boost::shared_ptr< RobotRaconteur::MessageElementData > *smartarg1 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > result;
  
  
  // intrusive_ptr by reference
  if ( jarg1 ) {
    smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElementData >**)&jarg1;
    temp1 = boost::intrusive_ptr<  RobotRaconteur::MessageElementData >(smartarg1->get(), true);
    arg1 = &temp1;
  } else {
    arg1 = &tempnull1;
  }
  
  
  try {
    result = MessageElementDataUtil::ToRRBaseArray((boost::intrusive_ptr< RobotRaconteur::MessageElementData > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = new boost::shared_ptr<  RobotRaconteur::RRBaseArray >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::RRBaseArray >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_ToMessageElementNestedElementList(void * jarg1) {
  void * jresult ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > *arg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > tempnull1 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > temp1 ;
  boost::shared_ptr< RobotRaconteur::MessageElementData > *smartarg1 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > result;
  
  
  // intrusive_ptr by reference
  if ( jarg1 ) {
    smartarg1 = *(boost::shared_ptr<  RobotRaconteur::MessageElementData >**)&jarg1;
    temp1 = boost::intrusive_ptr<  RobotRaconteur::MessageElementData >(smartarg1->get(), true);
    arg1 = &temp1;
  } else {
    arg1 = &tempnull1;
  }
  
  
  try {
    result = MessageElementDataUtil::ToMessageElementNestedElementList((boost::intrusive_ptr< RobotRaconteur::MessageElementData > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElementNestedElementList >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_RRBaseArrayToString(void * jarg1) {
  char * jresult ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull1 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp1 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg1 ;
  std::string result;
  
  
  // intrusive_ptr by reference
  if ( jarg1 ) {
    smartarg1 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg1;
    temp1 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg1->get(), true);
    arg1 = &temp1;
  } else {
    arg1 = &tempnull1;
  }
  
  
  try {
    result = MessageElementDataUtil::RRBaseArrayToString((boost::intrusive_ptr< RobotRaconteur::RRBaseArray > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_RRBaseArrayToDoubles(void * jarg1, double* jarg2, int jarg3) {
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg1 = 0 ;
  double *arg2 = (double *) 0 ;
  int32_t arg3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull1 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp1 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg1 ;
  
  
  // intrusive_ptr by reference
  if ( jarg1 ) {
    smartarg1 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg1;
    temp1 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg1->get(), true);
    arg1 = &temp1;
  } else {
    arg1 = &tempnull1;
  }
  
  arg2 = jarg2;
  arg3 = (int32_t)jarg3; 
  
  try {
    MessageElementDataUtil::RRBaseArrayToDoubles((boost::intrusive_ptr< RobotRaconteur::RRBaseArray > const &)*arg1,arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
  
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_RRBaseArrayToFloats(void * jarg1, float* jarg2, int jarg3) {
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg1 = 0 ;
  float *arg2 = (float *) 0 ;
  int32_t arg3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull1 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp1 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg1 ;
  
  
  // intrusive_ptr by reference
  if ( jarg1 ) {
    smartarg1 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg1;
    temp1 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg1->get(), true);
    arg1 = &temp1;
  } else {
    arg1 = &tempnull1;
  }
  
  arg2 = jarg2;
  arg3 = (int32_t)jarg3; 
  
  try {
    MessageElementDataUtil::RRBaseArrayToFloats((boost::intrusive_ptr< RobotRaconteur::RRBaseArray > const &)*arg1,arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
  
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_RRBaseArrayToBytes__SWIG_0(void * jarg1, signed char* jarg2, int jarg3) {
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg1 = 0 ;
  int8_t *arg2 = (int8_t *) 0 ;
  int32_t arg3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull1 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp1 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg1 ;
  
  
  // intrusive_ptr by reference
  if ( jarg1 ) {
    smartarg1 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg1;
    temp1 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg1->get(), true);
    arg1 = &temp1;
  } else {
    arg1 = &tempnull1;
  }
  
  arg2 = jarg2;
  arg3 = (int32_t)jarg3; 
  
  try {
    MessageElementDataUtil::RRBaseArrayToBytes((boost::intrusive_ptr< RobotRaconteur::RRBaseArray > const &)*arg1,arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
  
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_RRBaseArrayToBytes__SWIG_1(void * jarg1, unsigned char* jarg2, int jarg3) {
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg1 = 0 ;
  uint8_t *arg2 = (uint8_t *) 0 ;
  int32_t arg3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull1 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp1 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg1 ;
  
  
  // intrusive_ptr by reference
  if ( jarg1 ) {
    smartarg1 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg1;
    temp1 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg1->get(), true);
    arg1 = &temp1;
  } else {
    arg1 = &tempnull1;
  }
  
  arg2 = jarg2;
  arg3 = (int32_t)jarg3; 
  
  try {
    MessageElementDataUtil::RRBaseArrayToBytes((boost::intrusive_ptr< RobotRaconteur::RRBaseArray > const &)*arg1,arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
  
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_RRBaseArrayToShorts__SWIG_0(void * jarg1, short* jarg2, int jarg3) {
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg1 = 0 ;
  int16_t *arg2 = (int16_t *) 0 ;
  int32_t arg3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull1 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp1 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg1 ;
  
  
  // intrusive_ptr by reference
  if ( jarg1 ) {
    smartarg1 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg1;
    temp1 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg1->get(), true);
    arg1 = &temp1;
  } else {
    arg1 = &tempnull1;
  }
  
  arg2 = jarg2;
  arg3 = (int32_t)jarg3; 
  
  try {
    MessageElementDataUtil::RRBaseArrayToShorts((boost::intrusive_ptr< RobotRaconteur::RRBaseArray > const &)*arg1,arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
  
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_RRBaseArrayToShorts__SWIG_1(void * jarg1, unsigned short* jarg2, int jarg3) {
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg1 = 0 ;
  uint16_t *arg2 = (uint16_t *) 0 ;
  int32_t arg3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull1 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp1 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg1 ;
  
  
  // intrusive_ptr by reference
  if ( jarg1 ) {
    smartarg1 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg1;
    temp1 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg1->get(), true);
    arg1 = &temp1;
  } else {
    arg1 = &tempnull1;
  }
  
  arg2 = jarg2;
  arg3 = (int32_t)jarg3; 
  
  try {
    MessageElementDataUtil::RRBaseArrayToShorts((boost::intrusive_ptr< RobotRaconteur::RRBaseArray > const &)*arg1,arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
  
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_RRBaseArrayToInts__SWIG_0(void * jarg1, int* jarg2, int jarg3) {
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg1 = 0 ;
  int32_t *arg2 = (int32_t *) 0 ;
  int32_t arg3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull1 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp1 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg1 ;
  
  
  // intrusive_ptr by reference
  if ( jarg1 ) {
    smartarg1 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg1;
    temp1 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg1->get(), true);
    arg1 = &temp1;
  } else {
    arg1 = &tempnull1;
  }
  
  arg2 = jarg2;
  arg3 = (int32_t)jarg3; 
  
  try {
    MessageElementDataUtil::RRBaseArrayToInts((boost::intrusive_ptr< RobotRaconteur::RRBaseArray > const &)*arg1,arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
  
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_RRBaseArrayToInts__SWIG_1(void * jarg1, unsigned int* jarg2, int jarg3) {
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg1 = 0 ;
  uint32_t *arg2 = (uint32_t *) 0 ;
  int32_t arg3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull1 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp1 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg1 ;
  
  
  // intrusive_ptr by reference
  if ( jarg1 ) {
    smartarg1 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg1;
    temp1 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg1->get(), true);
    arg1 = &temp1;
  } else {
    arg1 = &tempnull1;
  }
  
  arg2 = jarg2;
  arg3 = (int32_t)jarg3; 
  
  try {
    MessageElementDataUtil::RRBaseArrayToInts((boost::intrusive_ptr< RobotRaconteur::RRBaseArray > const &)*arg1,arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
  
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_RRBaseArrayToLongs__SWIG_0(void * jarg1, long long* jarg2, int jarg3) {
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg1 = 0 ;
  int64_t *arg2 = (int64_t *) 0 ;
  int32_t arg3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull1 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp1 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg1 ;
  
  
  // intrusive_ptr by reference
  if ( jarg1 ) {
    smartarg1 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg1;
    temp1 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg1->get(), true);
    arg1 = &temp1;
  } else {
    arg1 = &tempnull1;
  }
  
  arg2 = jarg2;
  arg3 = (int32_t)jarg3; 
  
  try {
    MessageElementDataUtil::RRBaseArrayToLongs((boost::intrusive_ptr< RobotRaconteur::RRBaseArray > const &)*arg1,arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
  
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_RRBaseArrayToLongs__SWIG_1(void * jarg1, unsigned long long* jarg2, int jarg3) {
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg1 = 0 ;
  uint64_t *arg2 = (uint64_t *) 0 ;
  int32_t arg3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull1 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp1 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg1 ;
  
  
  // intrusive_ptr by reference
  if ( jarg1 ) {
    smartarg1 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg1;
    temp1 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg1->get(), true);
    arg1 = &temp1;
  } else {
    arg1 = &tempnull1;
  }
  
  arg2 = jarg2;
  arg3 = (int32_t)jarg3; 
  
  try {
    MessageElementDataUtil::RRBaseArrayToLongs((boost::intrusive_ptr< RobotRaconteur::RRBaseArray > const &)*arg1,arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
  
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_RRBaseArrayComplexToDoubles(void * jarg1, double* jarg2, int jarg3) {
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg1 = 0 ;
  double *arg2 = (double *) 0 ;
  int32_t arg3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull1 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp1 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg1 ;
  
  
  // intrusive_ptr by reference
  if ( jarg1 ) {
    smartarg1 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg1;
    temp1 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg1->get(), true);
    arg1 = &temp1;
  } else {
    arg1 = &tempnull1;
  }
  
  arg2 = jarg2;
  arg3 = (int32_t)jarg3; 
  
  try {
    MessageElementDataUtil::RRBaseArrayComplexToDoubles((boost::intrusive_ptr< RobotRaconteur::RRBaseArray > const &)*arg1,arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
  
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_RRBaseArrayComplexToFloats(void * jarg1, float* jarg2, int jarg3) {
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg1 = 0 ;
  float *arg2 = (float *) 0 ;
  int32_t arg3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull1 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp1 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg1 ;
  
  
  // intrusive_ptr by reference
  if ( jarg1 ) {
    smartarg1 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg1;
    temp1 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg1->get(), true);
    arg1 = &temp1;
  } else {
    arg1 = &tempnull1;
  }
  
  arg2 = jarg2;
  arg3 = (int32_t)jarg3; 
  
  try {
    MessageElementDataUtil::RRBaseArrayComplexToFloats((boost::intrusive_ptr< RobotRaconteur::RRBaseArray > const &)*arg1,arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
  
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_RRBaseArrayBoolToBytes__SWIG_0(void * jarg1, unsigned char* jarg2, int jarg3) {
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg1 = 0 ;
  uint8_t *arg2 = (uint8_t *) 0 ;
  int32_t arg3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull1 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp1 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg1 ;
  
  
  // intrusive_ptr by reference
  if ( jarg1 ) {
    smartarg1 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg1;
    temp1 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg1->get(), true);
    arg1 = &temp1;
  } else {
    arg1 = &tempnull1;
  }
  
  arg2 = jarg2;
  arg3 = (int32_t)jarg3; 
  
  try {
    MessageElementDataUtil::RRBaseArrayBoolToBytes((boost::intrusive_ptr< RobotRaconteur::RRBaseArray > const &)*arg1,arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
  
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_RRBaseArrayBoolToBytes__SWIG_1(void * jarg1, signed char* jarg2, int jarg3) {
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg1 = 0 ;
  int8_t *arg2 = (int8_t *) 0 ;
  int32_t arg3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull1 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp1 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg1 ;
  
  
  // intrusive_ptr by reference
  if ( jarg1 ) {
    smartarg1 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg1;
    temp1 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg1->get(), true);
    arg1 = &temp1;
  } else {
    arg1 = &tempnull1;
  }
  
  arg2 = jarg2;
  arg3 = (int32_t)jarg3; 
  
  try {
    MessageElementDataUtil::RRBaseArrayBoolToBytes((boost::intrusive_ptr< RobotRaconteur::RRBaseArray > const &)*arg1,arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
  
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_stringToRRBaseArray(char * jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  
  try {
    result = MessageElementDataUtil::stringToRRBaseArray((std::string const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = new boost::shared_ptr<  RobotRaconteur::RRBaseArray >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::RRBaseArray >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_DoublesToRRBaseArray__SWIG_0(double* jarg1, int jarg2) {
  void * jresult ;
  double *arg1 = (double *) 0 ;
  int32_t arg2 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > result;
  
  arg1 = jarg1;
  arg2 = (int32_t)jarg2; 
  
  try {
    result = MessageElementDataUtil::DoublesToRRBaseArray(arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = new boost::shared_ptr<  RobotRaconteur::RRBaseArray >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::RRBaseArray >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = 0;
  }
  
  
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_FloatsToRRBaseArray__SWIG_0(float* jarg1, int jarg2) {
  void * jresult ;
  float *arg1 = (float *) 0 ;
  int32_t arg2 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > result;
  
  arg1 = jarg1;
  arg2 = (int32_t)jarg2; 
  
  try {
    result = MessageElementDataUtil::FloatsToRRBaseArray(arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = new boost::shared_ptr<  RobotRaconteur::RRBaseArray >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::RRBaseArray >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = 0;
  }
  
  
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_BytesToRRBaseArray__SWIG_0(signed char* jarg1, int jarg2, int jarg3) {
  void * jresult ;
  int8_t *arg1 = (int8_t *) 0 ;
  int32_t arg2 ;
  RobotRaconteur::DataTypes arg3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > result;
  
  arg1 = jarg1;
  arg2 = (int32_t)jarg2; 
  arg3 = (RobotRaconteur::DataTypes)jarg3; 
  
  try {
    result = MessageElementDataUtil::BytesToRRBaseArray(arg1,arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = new boost::shared_ptr<  RobotRaconteur::RRBaseArray >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::RRBaseArray >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = 0;
  }
  
  
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_BytesToRRBaseArray__SWIG_1(unsigned char* jarg1, int jarg2) {
  void * jresult ;
  uint8_t *arg1 = (uint8_t *) 0 ;
  int32_t arg2 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > result;
  
  arg1 = jarg1;
  arg2 = (int32_t)jarg2; 
  
  try {
    result = MessageElementDataUtil::BytesToRRBaseArray(arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = new boost::shared_ptr<  RobotRaconteur::RRBaseArray >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::RRBaseArray >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = 0;
  }
  
  
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_ShortsToRRBaseArray__SWIG_0(short* jarg1, int jarg2, int jarg3) {
  void * jresult ;
  int16_t *arg1 = (int16_t *) 0 ;
  int32_t arg2 ;
  RobotRaconteur::DataTypes arg3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > result;
  
  arg1 = jarg1;
  arg2 = (int32_t)jarg2; 
  arg3 = (RobotRaconteur::DataTypes)jarg3; 
  
  try {
    result = MessageElementDataUtil::ShortsToRRBaseArray(arg1,arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = new boost::shared_ptr<  RobotRaconteur::RRBaseArray >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::RRBaseArray >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = 0;
  }
  
  
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_ShortsToRRBaseArray__SWIG_1(unsigned short* jarg1, int jarg2) {
  void * jresult ;
  uint16_t *arg1 = (uint16_t *) 0 ;
  int32_t arg2 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > result;
  
  arg1 = jarg1;
  arg2 = (int32_t)jarg2; 
  
  try {
    result = MessageElementDataUtil::ShortsToRRBaseArray(arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = new boost::shared_ptr<  RobotRaconteur::RRBaseArray >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::RRBaseArray >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = 0;
  }
  
  
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_IntsToRRBaseArray__SWIG_0(int* jarg1, int jarg2, int jarg3) {
  void * jresult ;
  int32_t *arg1 = (int32_t *) 0 ;
  int32_t arg2 ;
  RobotRaconteur::DataTypes arg3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > result;
  
  arg1 = jarg1;
  arg2 = (int32_t)jarg2; 
  arg3 = (RobotRaconteur::DataTypes)jarg3; 
  
  try {
    result = MessageElementDataUtil::IntsToRRBaseArray(arg1,arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = new boost::shared_ptr<  RobotRaconteur::RRBaseArray >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::RRBaseArray >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = 0;
  }
  
  
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_IntsToRRBaseArray__SWIG_1(unsigned int* jarg1, int jarg2) {
  void * jresult ;
  uint32_t *arg1 = (uint32_t *) 0 ;
  int32_t arg2 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > result;
  
  arg1 = jarg1;
  arg2 = (int32_t)jarg2; 
  
  try {
    result = MessageElementDataUtil::IntsToRRBaseArray(arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = new boost::shared_ptr<  RobotRaconteur::RRBaseArray >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::RRBaseArray >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = 0;
  }
  
  
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_LongsToRRBaseArray__SWIG_0(long long* jarg1, int jarg2, int jarg3) {
  void * jresult ;
  int64_t *arg1 = (int64_t *) 0 ;
  int32_t arg2 ;
  RobotRaconteur::DataTypes arg3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > result;
  
  arg1 = jarg1;
  arg2 = (int32_t)jarg2; 
  arg3 = (RobotRaconteur::DataTypes)jarg3; 
  
  try {
    result = MessageElementDataUtil::LongsToRRBaseArray(arg1,arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = new boost::shared_ptr<  RobotRaconteur::RRBaseArray >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::RRBaseArray >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = 0;
  }
  
  
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_LongsToRRBaseArray__SWIG_1(unsigned long long* jarg1, int jarg2) {
  void * jresult ;
  uint64_t *arg1 = (uint64_t *) 0 ;
  int32_t arg2 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > result;
  
  arg1 = jarg1;
  arg2 = (int32_t)jarg2; 
  
  try {
    result = MessageElementDataUtil::LongsToRRBaseArray(arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = new boost::shared_ptr<  RobotRaconteur::RRBaseArray >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::RRBaseArray >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = 0;
  }
  
  
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_DoublesToComplexRRBaseArray__SWIG_0(double* jarg1, int jarg2) {
  void * jresult ;
  double *arg1 = (double *) 0 ;
  int32_t arg2 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > result;
  
  arg1 = jarg1;
  arg2 = (int32_t)jarg2; 
  
  try {
    result = MessageElementDataUtil::DoublesToComplexRRBaseArray(arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = new boost::shared_ptr<  RobotRaconteur::RRBaseArray >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::RRBaseArray >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = 0;
  }
  
  
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_FloatsToComplexRRBaseArray__SWIG_0(float* jarg1, int jarg2) {
  void * jresult ;
  float *arg1 = (float *) 0 ;
  int32_t arg2 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > result;
  
  arg1 = jarg1;
  arg2 = (int32_t)jarg2; 
  
  try {
    result = MessageElementDataUtil::FloatsToComplexRRBaseArray(arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = new boost::shared_ptr<  RobotRaconteur::RRBaseArray >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::RRBaseArray >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = 0;
  }
  
  
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_BytesToBoolRRBaseArray__SWIG_0(unsigned char* jarg1, int jarg2) {
  void * jresult ;
  uint8_t *arg1 = (uint8_t *) 0 ;
  int32_t arg2 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > result;
  
  arg1 = jarg1;
  arg2 = (int32_t)jarg2; 
  
  try {
    result = MessageElementDataUtil::BytesToBoolRRBaseArray(arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = new boost::shared_ptr<  RobotRaconteur::RRBaseArray >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::RRBaseArray >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = 0;
  }
  
  
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_BytesToBoolRRBaseArray__SWIG_1(signed char* jarg1, int jarg2) {
  void * jresult ;
  int8_t *arg1 = (int8_t *) 0 ;
  int32_t arg2 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > result;
  
  arg1 = jarg1;
  arg2 = (int32_t)jarg2; 
  
  try {
    result = MessageElementDataUtil::BytesToBoolRRBaseArray(arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = new boost::shared_ptr<  RobotRaconteur::RRBaseArray >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::RRBaseArray >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = 0;
  }
  
  
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_DoublesToRRBaseArray__SWIG_1(double* jarg1, int jarg2, void * jarg3) {
  double *arg1 = (double *) 0 ;
  int32_t arg2 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp3 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg3 ;
  
  arg1 = jarg1;
  arg2 = (int32_t)jarg2; 
  
  // intrusive_ptr by reference
  if ( jarg3 ) {
    smartarg3 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg3;
    temp3 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg3->get(), true);
    arg3 = &temp3;
  } else {
    arg3 = &tempnull3;
  }
  
  
  try {
    MessageElementDataUtil::DoublesToRRBaseArray(arg1,arg2,(boost::intrusive_ptr< RobotRaconteur::RRBaseArray > const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
  
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_FloatsToRRBaseArray__SWIG_1(float* jarg1, int jarg2, void * jarg3) {
  float *arg1 = (float *) 0 ;
  int32_t arg2 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp3 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg3 ;
  
  arg1 = jarg1;
  arg2 = (int32_t)jarg2; 
  
  // intrusive_ptr by reference
  if ( jarg3 ) {
    smartarg3 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg3;
    temp3 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg3->get(), true);
    arg3 = &temp3;
  } else {
    arg3 = &tempnull3;
  }
  
  
  try {
    MessageElementDataUtil::FloatsToRRBaseArray(arg1,arg2,(boost::intrusive_ptr< RobotRaconteur::RRBaseArray > const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
  
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_BytesToRRBaseArray__SWIG_2(signed char* jarg1, int jarg2, void * jarg3) {
  int8_t *arg1 = (int8_t *) 0 ;
  int32_t arg2 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp3 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg3 ;
  
  arg1 = jarg1;
  arg2 = (int32_t)jarg2; 
  
  // intrusive_ptr by reference
  if ( jarg3 ) {
    smartarg3 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg3;
    temp3 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg3->get(), true);
    arg3 = &temp3;
  } else {
    arg3 = &tempnull3;
  }
  
  
  try {
    MessageElementDataUtil::BytesToRRBaseArray(arg1,arg2,(boost::intrusive_ptr< RobotRaconteur::RRBaseArray > const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
  
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_BytesToRRBaseArray__SWIG_3(unsigned char* jarg1, int jarg2, void * jarg3) {
  uint8_t *arg1 = (uint8_t *) 0 ;
  int32_t arg2 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp3 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg3 ;
  
  arg1 = jarg1;
  arg2 = (int32_t)jarg2; 
  
  // intrusive_ptr by reference
  if ( jarg3 ) {
    smartarg3 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg3;
    temp3 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg3->get(), true);
    arg3 = &temp3;
  } else {
    arg3 = &tempnull3;
  }
  
  
  try {
    MessageElementDataUtil::BytesToRRBaseArray(arg1,arg2,(boost::intrusive_ptr< RobotRaconteur::RRBaseArray > const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
  
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_ShortsToRRBaseArray__SWIG_2(short* jarg1, int jarg2, void * jarg3) {
  int16_t *arg1 = (int16_t *) 0 ;
  int32_t arg2 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp3 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg3 ;
  
  arg1 = jarg1;
  arg2 = (int32_t)jarg2; 
  
  // intrusive_ptr by reference
  if ( jarg3 ) {
    smartarg3 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg3;
    temp3 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg3->get(), true);
    arg3 = &temp3;
  } else {
    arg3 = &tempnull3;
  }
  
  
  try {
    MessageElementDataUtil::ShortsToRRBaseArray(arg1,arg2,(boost::intrusive_ptr< RobotRaconteur::RRBaseArray > const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
  
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_ShortsToRRBaseArray__SWIG_3(unsigned short* jarg1, int jarg2, void * jarg3) {
  uint16_t *arg1 = (uint16_t *) 0 ;
  int32_t arg2 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp3 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg3 ;
  
  arg1 = jarg1;
  arg2 = (int32_t)jarg2; 
  
  // intrusive_ptr by reference
  if ( jarg3 ) {
    smartarg3 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg3;
    temp3 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg3->get(), true);
    arg3 = &temp3;
  } else {
    arg3 = &tempnull3;
  }
  
  
  try {
    MessageElementDataUtil::ShortsToRRBaseArray(arg1,arg2,(boost::intrusive_ptr< RobotRaconteur::RRBaseArray > const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
  
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_IntsToRRBaseArray__SWIG_2(int* jarg1, int jarg2, void * jarg3) {
  int32_t *arg1 = (int32_t *) 0 ;
  int32_t arg2 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp3 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg3 ;
  
  arg1 = jarg1;
  arg2 = (int32_t)jarg2; 
  
  // intrusive_ptr by reference
  if ( jarg3 ) {
    smartarg3 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg3;
    temp3 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg3->get(), true);
    arg3 = &temp3;
  } else {
    arg3 = &tempnull3;
  }
  
  
  try {
    MessageElementDataUtil::IntsToRRBaseArray(arg1,arg2,(boost::intrusive_ptr< RobotRaconteur::RRBaseArray > const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
  
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_IntsToRRBaseArray__SWIG_3(unsigned int* jarg1, int jarg2, void * jarg3) {
  uint32_t *arg1 = (uint32_t *) 0 ;
  int32_t arg2 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp3 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg3 ;
  
  arg1 = jarg1;
  arg2 = (int32_t)jarg2; 
  
  // intrusive_ptr by reference
  if ( jarg3 ) {
    smartarg3 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg3;
    temp3 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg3->get(), true);
    arg3 = &temp3;
  } else {
    arg3 = &tempnull3;
  }
  
  
  try {
    MessageElementDataUtil::IntsToRRBaseArray(arg1,arg2,(boost::intrusive_ptr< RobotRaconteur::RRBaseArray > const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
  
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_LongsToRRBaseArray__SWIG_2(long long* jarg1, int jarg2, void * jarg3) {
  int64_t *arg1 = (int64_t *) 0 ;
  int32_t arg2 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp3 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg3 ;
  
  arg1 = jarg1;
  arg2 = (int32_t)jarg2; 
  
  // intrusive_ptr by reference
  if ( jarg3 ) {
    smartarg3 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg3;
    temp3 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg3->get(), true);
    arg3 = &temp3;
  } else {
    arg3 = &tempnull3;
  }
  
  
  try {
    MessageElementDataUtil::LongsToRRBaseArray(arg1,arg2,(boost::intrusive_ptr< RobotRaconteur::RRBaseArray > const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
  
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_LongsToRRBaseArray__SWIG_3(unsigned long long* jarg1, int jarg2, void * jarg3) {
  uint64_t *arg1 = (uint64_t *) 0 ;
  int32_t arg2 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp3 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg3 ;
  
  arg1 = jarg1;
  arg2 = (int32_t)jarg2; 
  
  // intrusive_ptr by reference
  if ( jarg3 ) {
    smartarg3 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg3;
    temp3 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg3->get(), true);
    arg3 = &temp3;
  } else {
    arg3 = &tempnull3;
  }
  
  
  try {
    MessageElementDataUtil::LongsToRRBaseArray(arg1,arg2,(boost::intrusive_ptr< RobotRaconteur::RRBaseArray > const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
  
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_DoublesToComplexRRBaseArray__SWIG_1(double* jarg1, int jarg2, void * jarg3) {
  double *arg1 = (double *) 0 ;
  int32_t arg2 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp3 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg3 ;
  
  arg1 = jarg1;
  arg2 = (int32_t)jarg2; 
  
  // intrusive_ptr by reference
  if ( jarg3 ) {
    smartarg3 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg3;
    temp3 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg3->get(), true);
    arg3 = &temp3;
  } else {
    arg3 = &tempnull3;
  }
  
  
  try {
    MessageElementDataUtil::DoublesToComplexRRBaseArray(arg1,arg2,(boost::intrusive_ptr< RobotRaconteur::RRBaseArray > const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
  
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_FloatsToComplexRRBaseArray__SWIG_1(float* jarg1, int jarg2, void * jarg3) {
  float *arg1 = (float *) 0 ;
  int32_t arg2 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp3 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg3 ;
  
  arg1 = jarg1;
  arg2 = (int32_t)jarg2; 
  
  // intrusive_ptr by reference
  if ( jarg3 ) {
    smartarg3 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg3;
    temp3 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg3->get(), true);
    arg3 = &temp3;
  } else {
    arg3 = &tempnull3;
  }
  
  
  try {
    MessageElementDataUtil::FloatsToComplexRRBaseArray(arg1,arg2,(boost::intrusive_ptr< RobotRaconteur::RRBaseArray > const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
  
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_BytesToBoolRRBaseArray__SWIG_2(signed char* jarg1, int jarg2, void * jarg3) {
  int8_t *arg1 = (int8_t *) 0 ;
  int32_t arg2 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp3 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg3 ;
  
  arg1 = jarg1;
  arg2 = (int32_t)jarg2; 
  
  // intrusive_ptr by reference
  if ( jarg3 ) {
    smartarg3 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg3;
    temp3 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg3->get(), true);
    arg3 = &temp3;
  } else {
    arg3 = &tempnull3;
  }
  
  
  try {
    MessageElementDataUtil::BytesToBoolRRBaseArray(arg1,arg2,(boost::intrusive_ptr< RobotRaconteur::RRBaseArray > const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
  
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_MessageElementDataUtil_BytesToBoolRRBaseArray__SWIG_3(unsigned char* jarg1, int jarg2, void * jarg3) {
  uint8_t *arg1 = (uint8_t *) 0 ;
  int32_t arg2 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp3 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg3 ;
  
  arg1 = jarg1;
  arg2 = (int32_t)jarg2; 
  
  // intrusive_ptr by reference
  if ( jarg3 ) {
    smartarg3 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg3;
    temp3 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg3->get(), true);
    arg3 = &temp3;
  } else {
    arg3 = &tempnull3;
  }
  
  
  try {
    MessageElementDataUtil::BytesToBoolRRBaseArray(arg1,arg2,(boost::intrusive_ptr< RobotRaconteur::RRBaseArray > const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
  
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_MessageElementDataUtil() {
  void * jresult ;
  MessageElementDataUtil *result = 0 ;
  
  
  try {
    result = (MessageElementDataUtil *)new MessageElementDataUtil();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_MessageElementDataUtil(void * jarg1) {
  MessageElementDataUtil *arg1 = (MessageElementDataUtil *) 0 ;
  
  arg1 = (MessageElementDataUtil *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_HandlerErrorInfo_error_code_set(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::HandlerErrorInfo *arg1 = (RobotRaconteur::HandlerErrorInfo *) 0 ;
  uint32_t arg2 ;
  
  arg1 = (RobotRaconteur::HandlerErrorInfo *)jarg1; 
  arg2 = (uint32_t)jarg2; 
  if (arg1) (arg1)->error_code = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_HandlerErrorInfo_error_code_get(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::HandlerErrorInfo *arg1 = (RobotRaconteur::HandlerErrorInfo *) 0 ;
  uint32_t result;
  
  arg1 = (RobotRaconteur::HandlerErrorInfo *)jarg1; 
  result = (uint32_t) ((arg1)->error_code);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_HandlerErrorInfo_errorname_set(void * jarg1, char * jarg2) {
  RobotRaconteur::HandlerErrorInfo *arg1 = (RobotRaconteur::HandlerErrorInfo *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::HandlerErrorInfo *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->errorname = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_HandlerErrorInfo_errorname_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::HandlerErrorInfo *arg1 = (RobotRaconteur::HandlerErrorInfo *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (RobotRaconteur::HandlerErrorInfo *)jarg1; 
  result = (std::string *) & ((arg1)->errorname);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_HandlerErrorInfo_errormessage_set(void * jarg1, char * jarg2) {
  RobotRaconteur::HandlerErrorInfo *arg1 = (RobotRaconteur::HandlerErrorInfo *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::HandlerErrorInfo *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->errormessage = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_HandlerErrorInfo_errormessage_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::HandlerErrorInfo *arg1 = (RobotRaconteur::HandlerErrorInfo *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (RobotRaconteur::HandlerErrorInfo *)jarg1; 
  result = (std::string *) & ((arg1)->errormessage);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_HandlerErrorInfo_errorsubname_set(void * jarg1, char * jarg2) {
  RobotRaconteur::HandlerErrorInfo *arg1 = (RobotRaconteur::HandlerErrorInfo *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::HandlerErrorInfo *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->errorsubname = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_HandlerErrorInfo_errorsubname_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::HandlerErrorInfo *arg1 = (RobotRaconteur::HandlerErrorInfo *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (RobotRaconteur::HandlerErrorInfo *)jarg1; 
  result = (std::string *) & ((arg1)->errorsubname);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_HandlerErrorInfo_param__set(void * jarg1, void * jarg2) {
  RobotRaconteur::HandlerErrorInfo *arg1 = (RobotRaconteur::HandlerErrorInfo *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *arg2 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > temp2 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg2 ;
  
  arg1 = (RobotRaconteur::HandlerErrorInfo *)jarg1; 
  
  // intrusive_ptr by reference
  if ( jarg2 ) {
    smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg2;
    temp2 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg2->get(), true);
    arg2 = &temp2;
  } else {
    arg2 = &tempnull2;
  }
  
  if (arg1) (arg1)->param_ = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_HandlerErrorInfo_param__get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::HandlerErrorInfo *arg1 = (RobotRaconteur::HandlerErrorInfo *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *result = 0 ;
  
  arg1 = (RobotRaconteur::HandlerErrorInfo *)jarg1; 
  result = (boost::intrusive_ptr< RobotRaconteur::MessageElement > *) & ((arg1)->param_);
  
  if (*result) {
    intrusive_ptr_add_ref(result->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >(result->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_HandlerErrorInfo() {
  void * jresult ;
  RobotRaconteur::HandlerErrorInfo *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::HandlerErrorInfo *)new RobotRaconteur::HandlerErrorInfo();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_HandlerErrorInfo(void * jarg1) {
  RobotRaconteur::HandlerErrorInfo *arg1 = (RobotRaconteur::HandlerErrorInfo *) 0 ;
  
  arg1 = (RobotRaconteur::HandlerErrorInfo *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_AsyncRequestDirector(void * jarg1) {
  RobotRaconteur::AsyncRequestDirector *arg1 = (RobotRaconteur::AsyncRequestDirector *) 0 ;
  
  arg1 = (RobotRaconteur::AsyncRequestDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AsyncRequestDirector_handler(void * jarg1, void * jarg2, void * jarg3) {
  RobotRaconteur::AsyncRequestDirector *arg1 = (RobotRaconteur::AsyncRequestDirector *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > arg2 ;
  RobotRaconteur::HandlerErrorInfo *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg2 ;
  
  arg1 = (RobotRaconteur::AsyncRequestDirector *)jarg1; 
  
  // intrusive_ptr by value
  smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg2;
  if (smartarg2) {
    arg2 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg2->get(), true);
  }
  
  arg3 = (RobotRaconteur::HandlerErrorInfo *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::HandlerErrorInfo & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->handler(arg2,*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_AsyncRequestDirector() {
  void * jresult ;
  RobotRaconteur::AsyncRequestDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::AsyncRequestDirector *)new SwigDirector_AsyncRequestDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AsyncRequestDirector_director_connect(void *objarg, SwigDirector_AsyncRequestDirector::SWIG_Callback0_t callback0) {
  RobotRaconteur::AsyncRequestDirector *obj = (RobotRaconteur::AsyncRequestDirector *)objarg;
  SwigDirector_AsyncRequestDirector *director = static_cast<SwigDirector_AsyncRequestDirector *>(obj);
  director->swig_connect_director(callback0);
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_AsyncVoidReturnDirector(void * jarg1) {
  RobotRaconteur::AsyncVoidReturnDirector *arg1 = (RobotRaconteur::AsyncVoidReturnDirector *) 0 ;
  
  arg1 = (RobotRaconteur::AsyncVoidReturnDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AsyncVoidReturnDirector_handler(void * jarg1, void * jarg2) {
  RobotRaconteur::AsyncVoidReturnDirector *arg1 = (RobotRaconteur::AsyncVoidReturnDirector *) 0 ;
  RobotRaconteur::HandlerErrorInfo *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::AsyncVoidReturnDirector *)jarg1; 
  arg2 = (RobotRaconteur::HandlerErrorInfo *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::HandlerErrorInfo & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->handler(*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_AsyncVoidReturnDirector() {
  void * jresult ;
  RobotRaconteur::AsyncVoidReturnDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::AsyncVoidReturnDirector *)new SwigDirector_AsyncVoidReturnDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AsyncVoidReturnDirector_director_connect(void *objarg, SwigDirector_AsyncVoidReturnDirector::SWIG_Callback0_t callback0) {
  RobotRaconteur::AsyncVoidReturnDirector *obj = (RobotRaconteur::AsyncVoidReturnDirector *)objarg;
  SwigDirector_AsyncVoidReturnDirector *director = static_cast<SwigDirector_AsyncVoidReturnDirector *>(obj);
  director->swig_connect_director(callback0);
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_AsyncVoidNoErrReturnDirector(void * jarg1) {
  RobotRaconteur::AsyncVoidNoErrReturnDirector *arg1 = (RobotRaconteur::AsyncVoidNoErrReturnDirector *) 0 ;
  
  arg1 = (RobotRaconteur::AsyncVoidNoErrReturnDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AsyncVoidNoErrReturnDirector_handler(void * jarg1) {
  RobotRaconteur::AsyncVoidNoErrReturnDirector *arg1 = (RobotRaconteur::AsyncVoidNoErrReturnDirector *) 0 ;
  
  arg1 = (RobotRaconteur::AsyncVoidNoErrReturnDirector *)jarg1; 
  
  try {
    (arg1)->handler();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_AsyncVoidNoErrReturnDirector() {
  void * jresult ;
  RobotRaconteur::AsyncVoidNoErrReturnDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::AsyncVoidNoErrReturnDirector *)new SwigDirector_AsyncVoidNoErrReturnDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AsyncVoidNoErrReturnDirector_director_connect(void *objarg, SwigDirector_AsyncVoidNoErrReturnDirector::SWIG_Callback0_t callback0) {
  RobotRaconteur::AsyncVoidNoErrReturnDirector *obj = (RobotRaconteur::AsyncVoidNoErrReturnDirector *)objarg;
  SwigDirector_AsyncVoidNoErrReturnDirector *director = static_cast<SwigDirector_AsyncVoidNoErrReturnDirector *>(obj);
  director->swig_connect_director(callback0);
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_AsyncStringReturnDirector(void * jarg1) {
  RobotRaconteur::AsyncStringReturnDirector *arg1 = (RobotRaconteur::AsyncStringReturnDirector *) 0 ;
  
  arg1 = (RobotRaconteur::AsyncStringReturnDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AsyncStringReturnDirector_handler(void * jarg1, char * jarg2, void * jarg3) {
  RobotRaconteur::AsyncStringReturnDirector *arg1 = (RobotRaconteur::AsyncStringReturnDirector *) 0 ;
  std::string *arg2 = 0 ;
  RobotRaconteur::HandlerErrorInfo *arg3 = 0 ;
  
  arg1 = (RobotRaconteur::AsyncStringReturnDirector *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (RobotRaconteur::HandlerErrorInfo *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::HandlerErrorInfo & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->handler((std::string const &)*arg2,*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_AsyncStringReturnDirector() {
  void * jresult ;
  RobotRaconteur::AsyncStringReturnDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::AsyncStringReturnDirector *)new SwigDirector_AsyncStringReturnDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AsyncStringReturnDirector_director_connect(void *objarg, SwigDirector_AsyncStringReturnDirector::SWIG_Callback0_t callback0) {
  RobotRaconteur::AsyncStringReturnDirector *obj = (RobotRaconteur::AsyncStringReturnDirector *)objarg;
  SwigDirector_AsyncStringReturnDirector *director = static_cast<SwigDirector_AsyncStringReturnDirector *>(obj);
  director->swig_connect_director(callback0);
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_AsyncUInt32ReturnDirector(void * jarg1) {
  RobotRaconteur::AsyncUInt32ReturnDirector *arg1 = (RobotRaconteur::AsyncUInt32ReturnDirector *) 0 ;
  
  arg1 = (RobotRaconteur::AsyncUInt32ReturnDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AsyncUInt32ReturnDirector_handler(void * jarg1, unsigned int jarg2, void * jarg3) {
  RobotRaconteur::AsyncUInt32ReturnDirector *arg1 = (RobotRaconteur::AsyncUInt32ReturnDirector *) 0 ;
  uint32_t arg2 ;
  RobotRaconteur::HandlerErrorInfo *arg3 = 0 ;
  
  arg1 = (RobotRaconteur::AsyncUInt32ReturnDirector *)jarg1; 
  arg2 = (uint32_t)jarg2; 
  arg3 = (RobotRaconteur::HandlerErrorInfo *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::HandlerErrorInfo & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->handler(arg2,*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_AsyncUInt32ReturnDirector() {
  void * jresult ;
  RobotRaconteur::AsyncUInt32ReturnDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::AsyncUInt32ReturnDirector *)new SwigDirector_AsyncUInt32ReturnDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AsyncUInt32ReturnDirector_director_connect(void *objarg, SwigDirector_AsyncUInt32ReturnDirector::SWIG_Callback0_t callback0) {
  RobotRaconteur::AsyncUInt32ReturnDirector *obj = (RobotRaconteur::AsyncUInt32ReturnDirector *)objarg;
  SwigDirector_AsyncUInt32ReturnDirector *director = static_cast<SwigDirector_AsyncUInt32ReturnDirector *>(obj);
  director->swig_connect_director(callback0);
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_rr_memcpy_memcpy(void * jarg1, void * jarg2, long long jarg3) {
  void *arg1 = (void *) 0 ;
  void *arg2 = (void *) 0 ;
  int64_t arg3 ;
  
  arg1 = (void *)jarg1; 
  arg2 = (void *)jarg2; 
  arg3 = (int64_t)jarg3; 
  
  try {
    rr_memcpy::memcpy(arg1,arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_Transport_GetUrlSchemeString(void * jarg1) {
  char * jresult ;
  RobotRaconteur::Transport *arg1 = (RobotRaconteur::Transport *) 0 ;
  boost::shared_ptr< RobotRaconteur::Transport const > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr< const RobotRaconteur::Transport > *)jarg1;
  arg1 = (RobotRaconteur::Transport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = ((RobotRaconteur::Transport const *)arg1)->GetUrlSchemeString();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_Transport_GetCurrentTransportConnectionURL() {
  char * jresult ;
  std::string result;
  
  
  try {
    result = RobotRaconteur::Transport::GetCurrentTransportConnectionURL();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_Transport_GetServerListenUrls(void * jarg1) {
  void * jresult ;
  RobotRaconteur::Transport *arg1 = (RobotRaconteur::Transport *) 0 ;
  boost::shared_ptr< RobotRaconteur::Transport > *smartarg1 = 0 ;
  std::vector< std::string > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::Transport > *)jarg1;
  arg1 = (RobotRaconteur::Transport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetServerListenUrls();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< std::string >((const std::vector< std::string > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_Transport(void * jarg1) {
  RobotRaconteur::Transport *arg1 = (RobotRaconteur::Transport *) 0 ;
  boost::shared_ptr< RobotRaconteur::Transport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::Transport > *)jarg1;
  arg1 = (RobotRaconteur::Transport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_TcpTransport__SWIG_0() {
  void * jresult ;
  RobotRaconteur::TcpTransport *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::TcpTransport *)new RobotRaconteur::TcpTransport();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::TcpTransport >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_TcpTransport__SWIG_1(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  RobotRaconteur::TcpTransport *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  
  try {
    result = (RobotRaconteur::TcpTransport *)new RobotRaconteur::TcpTransport((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::TcpTransport >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport__GetDefaultReceiveTimeout(void * jarg1) {
  int jresult ;
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  int32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (int32_t)(arg1)->GetDefaultReceiveTimeout();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport__SetDefaultReceiveTimeout(void * jarg1, int jarg2) {
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  int32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  
  try {
    (arg1)->SetDefaultReceiveTimeout(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport__GetDefaultConnectTimeout(void * jarg1) {
  int jresult ;
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  int32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (int32_t)(arg1)->GetDefaultConnectTimeout();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport__SetDefaultConnectTimeout(void * jarg1, int jarg2) {
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  int32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  
  try {
    (arg1)->SetDefaultConnectTimeout(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport__GetDefaultHeartbeatPeriod(void * jarg1) {
  int jresult ;
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  int32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (int32_t)(arg1)->GetDefaultHeartbeatPeriod();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport__SetDefaultHeartbeatPeriod(void * jarg1, int jarg2) {
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  int32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  
  try {
    (arg1)->SetDefaultHeartbeatPeriod(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport_GetUrlSchemeString(void * jarg1) {
  char * jresult ;
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport const > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr< const RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = ((RobotRaconteur::TcpTransport const *)arg1)->GetUrlSchemeString();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport_GetServerListenUrls(void * jarg1) {
  void * jresult ;
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  std::vector< std::string > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetServerListenUrls();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< std::string >((const std::vector< std::string > &)result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport_GetListenPort(void * jarg1) {
  int jresult ;
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  int32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (int32_t)(arg1)->GetListenPort();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport_StartServer__SWIG_0(void * jarg1, int jarg2, unsigned int jarg3) {
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  int32_t arg2 ;
  bool arg3 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  arg3 = jarg3 ? true : false; 
  
  try {
    (arg1)->StartServer(arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport_StartServer__SWIG_1(void * jarg1, int jarg2) {
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  int32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  
  try {
    (arg1)->StartServer(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport_Close(void * jarg1) {
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->Close();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport_EnableNodeDiscoveryListening__SWIG_0(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  uint32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (uint32_t)jarg2; 
  
  try {
    (arg1)->EnableNodeDiscoveryListening(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport_EnableNodeDiscoveryListening__SWIG_1(void * jarg1) {
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->EnableNodeDiscoveryListening();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport_DisableNodeDiscoveryListening(void * jarg1) {
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->DisableNodeDiscoveryListening();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport_EnableNodeAnnounce__SWIG_0(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  uint32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (uint32_t)jarg2; 
  
  try {
    (arg1)->EnableNodeAnnounce(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport_EnableNodeAnnounce__SWIG_1(void * jarg1) {
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->EnableNodeAnnounce();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport_DisableNodeAnnounce(void * jarg1) {
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->DisableNodeAnnounce();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport__GetNodeAnnouncePeriod(void * jarg1) {
  int jresult ;
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  int32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (int32_t)(arg1)->GetNodeAnnouncePeriod();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport__SetNodeAnnouncePeriod(void * jarg1, int jarg2) {
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  int32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  
  try {
    (arg1)->SetNodeAnnouncePeriod(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport__GetMaxMessageSize(void * jarg1) {
  int jresult ;
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  int32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (int32_t)(arg1)->GetMaxMessageSize();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport__SetMaxMessageSize(void * jarg1, int jarg2) {
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  int32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  
  try {
    (arg1)->SetMaxMessageSize(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport__GetMaxConnectionCount(void * jarg1) {
  int jresult ;
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  int32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (int32_t)(arg1)->GetMaxConnectionCount();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport__SetMaxConnectionCount(void * jarg1, int jarg2) {
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  int32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  
  try {
    (arg1)->SetMaxConnectionCount(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport__GetRequireTls(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->GetRequireTls();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport__SetRequireTls(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  bool arg2 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? true : false; 
  
  try {
    (arg1)->SetRequireTls(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport_LoadTlsNodeCertificate(void * jarg1) {
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->LoadTlsNodeCertificate();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport__IsTlsNodeCertificateLoaded(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->IsTlsNodeCertificateLoaded();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport_IsTransportConnectionSecure(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ;
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  uint32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (uint32_t)jarg2; 
  
  try {
    result = (bool)(arg1)->IsTransportConnectionSecure(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport__IsTransportConnectionSecure(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::RRObject > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RRObject > tempnull2 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::RRObject > *)jarg2 : &tempnull2; 
  
  try {
    result = (bool)(arg1)->IsTransportConnectionSecure((boost::shared_ptr< RobotRaconteur::RRObject > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport_IsSecurePeerIdentityVerified(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ;
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  uint32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (uint32_t)jarg2; 
  
  try {
    result = (bool)(arg1)->IsSecurePeerIdentityVerified(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport__IsSecurePeerIdentityVerified(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::RRObject > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RRObject > tempnull2 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::RRObject > *)jarg2 : &tempnull2; 
  
  try {
    result = (bool)(arg1)->IsSecurePeerIdentityVerified((boost::shared_ptr< RobotRaconteur::RRObject > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport_GetSecurePeerIdentity(void * jarg1, unsigned int jarg2) {
  char * jresult ;
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  uint32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (uint32_t)jarg2; 
  
  try {
    result = (arg1)->GetSecurePeerIdentity(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport__GetSecurePeerIdentity(void * jarg1, void * jarg2) {
  char * jresult ;
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::RRObject > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RRObject > tempnull2 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::RRObject > *)jarg2 : &tempnull2; 
  
  try {
    result = (arg1)->GetSecurePeerIdentity((boost::shared_ptr< RobotRaconteur::RRObject > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport_StartServerUsingPortSharer(void * jarg1) {
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->StartServerUsingPortSharer();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport__IsPortSharerRunning(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->IsPortSharerRunning();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport__GetAcceptWebSockets(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->GetAcceptWebSockets();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport__SetAcceptWebSockets(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  bool arg2 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? true : false; 
  
  try {
    (arg1)->SetAcceptWebSockets(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport_GetWebSocketAllowedOrigins(void * jarg1) {
  void * jresult ;
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  std::vector< std::string > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetWebSocketAllowedOrigins();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< std::string >((const std::vector< std::string > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport_AddWebSocketAllowedOrigin(void * jarg1, char * jarg2) {
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->AddWebSocketAllowedOrigin((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport_RemoveWebSocketAllowedOrigin(void * jarg1, char * jarg2) {
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->RemoveWebSocketAllowedOrigin((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport__GetDisableMessage4(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->GetDisableMessage4();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport__SetDisableMessage4(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  bool arg2 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? true : false; 
  
  try {
    (arg1)->SetDisableMessage4(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport__GetDisableStringTable(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->GetDisableStringTable();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport__SetDisableStringTable(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  bool arg2 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? true : false; 
  
  try {
    (arg1)->SetDisableStringTable(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport__GetDisableAsyncMessageIO(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->GetDisableAsyncMessageIO();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport__SetDisableAsyncMessageIO(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  bool arg2 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? true : false; 
  
  try {
    (arg1)->SetDisableAsyncMessageIO(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport_GetLocalAdapterIPAddresses() {
  void * jresult ;
  std::vector< std::string > result;
  
  
  try {
    result = RobotRaconteur_TcpTransport_GetLocalAdapterIPAddresses();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< std::string >((const std::vector< std::string > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_TcpTransport(void * jarg1) {
  RobotRaconteur::TcpTransport *arg1 = (RobotRaconteur::TcpTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::TcpTransport > *)jarg1;
  arg1 = (RobotRaconteur::TcpTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_LocalTransport__SWIG_0() {
  void * jresult ;
  RobotRaconteur::LocalTransport *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::LocalTransport *)new RobotRaconteur::LocalTransport();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::LocalTransport >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_LocalTransport__SWIG_1(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  RobotRaconteur::LocalTransport *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  
  try {
    result = (RobotRaconteur::LocalTransport *)new RobotRaconteur::LocalTransport((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::LocalTransport >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_LocalTransport_IsLocalTransportSupported() {
  unsigned int jresult ;
  bool result;
  
  
  try {
    result = (bool)RobotRaconteur::LocalTransport::IsLocalTransportSupported();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_LocalTransport_GetUrlSchemeString(void * jarg1) {
  char * jresult ;
  RobotRaconteur::LocalTransport *arg1 = (RobotRaconteur::LocalTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::LocalTransport const > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr< const RobotRaconteur::LocalTransport > *)jarg1;
  arg1 = (RobotRaconteur::LocalTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = ((RobotRaconteur::LocalTransport const *)arg1)->GetUrlSchemeString();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_LocalTransport_GetServerListenUrls(void * jarg1) {
  void * jresult ;
  RobotRaconteur::LocalTransport *arg1 = (RobotRaconteur::LocalTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::LocalTransport > *smartarg1 = 0 ;
  std::vector< std::string > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::LocalTransport > *)jarg1;
  arg1 = (RobotRaconteur::LocalTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetServerListenUrls();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< std::string >((const std::vector< std::string > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_LocalTransport_StartClientAsNodeName(void * jarg1, char * jarg2) {
  RobotRaconteur::LocalTransport *arg1 = (RobotRaconteur::LocalTransport *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::LocalTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::LocalTransport > *)jarg1;
  arg1 = (RobotRaconteur::LocalTransport *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->StartClientAsNodeName((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_LocalTransport_StartServerAsNodeName__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
  RobotRaconteur::LocalTransport *arg1 = (RobotRaconteur::LocalTransport *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  boost::shared_ptr< RobotRaconteur::LocalTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::LocalTransport > *)jarg1;
  arg1 = (RobotRaconteur::LocalTransport *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  
  try {
    (arg1)->StartServerAsNodeName((std::string const &)*arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_LocalTransport_StartServerAsNodeName__SWIG_1(void * jarg1, char * jarg2) {
  RobotRaconteur::LocalTransport *arg1 = (RobotRaconteur::LocalTransport *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::LocalTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::LocalTransport > *)jarg1;
  arg1 = (RobotRaconteur::LocalTransport *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->StartServerAsNodeName((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_LocalTransport_StartServerAsNodeID__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3) {
  RobotRaconteur::LocalTransport *arg1 = (RobotRaconteur::LocalTransport *) 0 ;
  RobotRaconteur::NodeID *arg2 = 0 ;
  bool arg3 ;
  boost::shared_ptr< RobotRaconteur::LocalTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::LocalTransport > *)jarg1;
  arg1 = (RobotRaconteur::LocalTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::NodeID *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::NodeID const & type is null", 0);
    return ;
  } 
  arg3 = jarg3 ? true : false; 
  
  try {
    (arg1)->StartServerAsNodeID((RobotRaconteur::NodeID const &)*arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_LocalTransport_StartServerAsNodeID__SWIG_1(void * jarg1, void * jarg2) {
  RobotRaconteur::LocalTransport *arg1 = (RobotRaconteur::LocalTransport *) 0 ;
  RobotRaconteur::NodeID *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::LocalTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::LocalTransport > *)jarg1;
  arg1 = (RobotRaconteur::LocalTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::NodeID *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::NodeID const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->StartServerAsNodeID((RobotRaconteur::NodeID const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_LocalTransport_Close(void * jarg1) {
  RobotRaconteur::LocalTransport *arg1 = (RobotRaconteur::LocalTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::LocalTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::LocalTransport > *)jarg1;
  arg1 = (RobotRaconteur::LocalTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->Close();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_LocalTransport__GetMaxMessageSize(void * jarg1) {
  int jresult ;
  RobotRaconteur::LocalTransport *arg1 = (RobotRaconteur::LocalTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::LocalTransport > *smartarg1 = 0 ;
  int32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::LocalTransport > *)jarg1;
  arg1 = (RobotRaconteur::LocalTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (int32_t)(arg1)->GetMaxMessageSize();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_LocalTransport__SetMaxMessageSize(void * jarg1, int jarg2) {
  RobotRaconteur::LocalTransport *arg1 = (RobotRaconteur::LocalTransport *) 0 ;
  int32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::LocalTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::LocalTransport > *)jarg1;
  arg1 = (RobotRaconteur::LocalTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  
  try {
    (arg1)->SetMaxMessageSize(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_LocalTransport__GetDisableMessage4(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::LocalTransport *arg1 = (RobotRaconteur::LocalTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::LocalTransport > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::LocalTransport > *)jarg1;
  arg1 = (RobotRaconteur::LocalTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->GetDisableMessage4();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_LocalTransport__SetDisableMessage4(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::LocalTransport *arg1 = (RobotRaconteur::LocalTransport *) 0 ;
  bool arg2 ;
  boost::shared_ptr< RobotRaconteur::LocalTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::LocalTransport > *)jarg1;
  arg1 = (RobotRaconteur::LocalTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? true : false; 
  
  try {
    (arg1)->SetDisableMessage4(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_LocalTransport__GetDisableStringTable(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::LocalTransport *arg1 = (RobotRaconteur::LocalTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::LocalTransport > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::LocalTransport > *)jarg1;
  arg1 = (RobotRaconteur::LocalTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->GetDisableStringTable();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_LocalTransport__SetDisableStringTable(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::LocalTransport *arg1 = (RobotRaconteur::LocalTransport *) 0 ;
  bool arg2 ;
  boost::shared_ptr< RobotRaconteur::LocalTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::LocalTransport > *)jarg1;
  arg1 = (RobotRaconteur::LocalTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? true : false; 
  
  try {
    (arg1)->SetDisableStringTable(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_LocalTransport__GetDisableAsyncMessageIO(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::LocalTransport *arg1 = (RobotRaconteur::LocalTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::LocalTransport > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::LocalTransport > *)jarg1;
  arg1 = (RobotRaconteur::LocalTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->GetDisableAsyncMessageIO();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_LocalTransport__SetDisableAsyncMessageIO(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::LocalTransport *arg1 = (RobotRaconteur::LocalTransport *) 0 ;
  bool arg2 ;
  boost::shared_ptr< RobotRaconteur::LocalTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::LocalTransport > *)jarg1;
  arg1 = (RobotRaconteur::LocalTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? true : false; 
  
  try {
    (arg1)->SetDisableAsyncMessageIO(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_LocalTransport_EnableNodeDiscoveryListening(void * jarg1) {
  RobotRaconteur::LocalTransport *arg1 = (RobotRaconteur::LocalTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::LocalTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::LocalTransport > *)jarg1;
  arg1 = (RobotRaconteur::LocalTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->EnableNodeDiscoveryListening();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_LocalTransport_DisableNodeDiscoveryListening(void * jarg1) {
  RobotRaconteur::LocalTransport *arg1 = (RobotRaconteur::LocalTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::LocalTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::LocalTransport > *)jarg1;
  arg1 = (RobotRaconteur::LocalTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->DisableNodeDiscoveryListening();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_LocalTransport(void * jarg1) {
  RobotRaconteur::LocalTransport *arg1 = (RobotRaconteur::LocalTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::LocalTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::LocalTransport > *)jarg1;
  arg1 = (RobotRaconteur::LocalTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_HardwareTransport__SWIG_0() {
  void * jresult ;
  RobotRaconteur::HardwareTransport *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::HardwareTransport *)new RobotRaconteur::HardwareTransport();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::HardwareTransport >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_HardwareTransport__SWIG_1(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  RobotRaconteur::HardwareTransport *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  
  try {
    result = (RobotRaconteur::HardwareTransport *)new RobotRaconteur::HardwareTransport((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::HardwareTransport >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_HardwareTransport_GetUrlSchemeString(void * jarg1) {
  char * jresult ;
  RobotRaconteur::HardwareTransport *arg1 = (RobotRaconteur::HardwareTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::HardwareTransport const > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr< const RobotRaconteur::HardwareTransport > *)jarg1;
  arg1 = (RobotRaconteur::HardwareTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = ((RobotRaconteur::HardwareTransport const *)arg1)->GetUrlSchemeString();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_HardwareTransport_GetServerListenUrls(void * jarg1) {
  void * jresult ;
  RobotRaconteur::HardwareTransport *arg1 = (RobotRaconteur::HardwareTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::HardwareTransport > *smartarg1 = 0 ;
  std::vector< std::string > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::HardwareTransport > *)jarg1;
  arg1 = (RobotRaconteur::HardwareTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetServerListenUrls();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< std::string >((const std::vector< std::string > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_HardwareTransport_Close(void * jarg1) {
  RobotRaconteur::HardwareTransport *arg1 = (RobotRaconteur::HardwareTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::HardwareTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::HardwareTransport > *)jarg1;
  arg1 = (RobotRaconteur::HardwareTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->Close();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_HardwareTransport__GetMaxMessageSize(void * jarg1) {
  int jresult ;
  RobotRaconteur::HardwareTransport *arg1 = (RobotRaconteur::HardwareTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::HardwareTransport > *smartarg1 = 0 ;
  int32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::HardwareTransport > *)jarg1;
  arg1 = (RobotRaconteur::HardwareTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (int32_t)(arg1)->GetMaxMessageSize();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_HardwareTransport__SetMaxMessageSize(void * jarg1, int jarg2) {
  RobotRaconteur::HardwareTransport *arg1 = (RobotRaconteur::HardwareTransport *) 0 ;
  int32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::HardwareTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::HardwareTransport > *)jarg1;
  arg1 = (RobotRaconteur::HardwareTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  
  try {
    (arg1)->SetMaxMessageSize(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_HardwareTransport__GetDisableMessage4(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::HardwareTransport *arg1 = (RobotRaconteur::HardwareTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::HardwareTransport > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::HardwareTransport > *)jarg1;
  arg1 = (RobotRaconteur::HardwareTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->GetDisableMessage4();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_HardwareTransport__SetDisableMessage4(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::HardwareTransport *arg1 = (RobotRaconteur::HardwareTransport *) 0 ;
  bool arg2 ;
  boost::shared_ptr< RobotRaconteur::HardwareTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::HardwareTransport > *)jarg1;
  arg1 = (RobotRaconteur::HardwareTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? true : false; 
  
  try {
    (arg1)->SetDisableMessage4(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_HardwareTransport__GetDisableStringTable(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::HardwareTransport *arg1 = (RobotRaconteur::HardwareTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::HardwareTransport > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::HardwareTransport > *)jarg1;
  arg1 = (RobotRaconteur::HardwareTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->GetDisableStringTable();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_HardwareTransport__SetDisableStringTable(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::HardwareTransport *arg1 = (RobotRaconteur::HardwareTransport *) 0 ;
  bool arg2 ;
  boost::shared_ptr< RobotRaconteur::HardwareTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::HardwareTransport > *)jarg1;
  arg1 = (RobotRaconteur::HardwareTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? true : false; 
  
  try {
    (arg1)->SetDisableStringTable(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_HardwareTransport__GetDisableAsyncMessageIO(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::HardwareTransport *arg1 = (RobotRaconteur::HardwareTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::HardwareTransport > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::HardwareTransport > *)jarg1;
  arg1 = (RobotRaconteur::HardwareTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->GetDisableAsyncMessageIO();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_HardwareTransport__SetDisableAsyncMessageIO(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::HardwareTransport *arg1 = (RobotRaconteur::HardwareTransport *) 0 ;
  bool arg2 ;
  boost::shared_ptr< RobotRaconteur::HardwareTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::HardwareTransport > *)jarg1;
  arg1 = (RobotRaconteur::HardwareTransport *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? true : false; 
  
  try {
    (arg1)->SetDisableAsyncMessageIO(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_HardwareTransport(void * jarg1) {
  RobotRaconteur::HardwareTransport *arg1 = (RobotRaconteur::HardwareTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::HardwareTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::HardwareTransport > *)jarg1;
  arg1 = (RobotRaconteur::HardwareTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_IntraTransport__SWIG_0() {
  void * jresult ;
  RobotRaconteur::IntraTransport *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::IntraTransport *)new RobotRaconteur::IntraTransport();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::IntraTransport >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_IntraTransport__SWIG_1(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  RobotRaconteur::IntraTransport *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  
  try {
    result = (RobotRaconteur::IntraTransport *)new RobotRaconteur::IntraTransport((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::IntraTransport >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_IntraTransport_GetUrlSchemeString(void * jarg1) {
  char * jresult ;
  RobotRaconteur::IntraTransport *arg1 = (RobotRaconteur::IntraTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::IntraTransport const > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr< const RobotRaconteur::IntraTransport > *)jarg1;
  arg1 = (RobotRaconteur::IntraTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = ((RobotRaconteur::IntraTransport const *)arg1)->GetUrlSchemeString();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_IntraTransport_GetServerListenUrls(void * jarg1) {
  void * jresult ;
  RobotRaconteur::IntraTransport *arg1 = (RobotRaconteur::IntraTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::IntraTransport > *smartarg1 = 0 ;
  std::vector< std::string > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::IntraTransport > *)jarg1;
  arg1 = (RobotRaconteur::IntraTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetServerListenUrls();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< std::string >((const std::vector< std::string > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_IntraTransport_Close(void * jarg1) {
  RobotRaconteur::IntraTransport *arg1 = (RobotRaconteur::IntraTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::IntraTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::IntraTransport > *)jarg1;
  arg1 = (RobotRaconteur::IntraTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->Close();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_IntraTransport_StartClient(void * jarg1) {
  RobotRaconteur::IntraTransport *arg1 = (RobotRaconteur::IntraTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::IntraTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::IntraTransport > *)jarg1;
  arg1 = (RobotRaconteur::IntraTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->StartClient();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_IntraTransport_StartServer(void * jarg1) {
  RobotRaconteur::IntraTransport *arg1 = (RobotRaconteur::IntraTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::IntraTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::IntraTransport > *)jarg1;
  arg1 = (RobotRaconteur::IntraTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->StartServer();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_IntraTransport(void * jarg1) {
  RobotRaconteur::IntraTransport *arg1 = (RobotRaconteur::IntraTransport *) 0 ;
  boost::shared_ptr< RobotRaconteur::IntraTransport > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::IntraTransport > *)jarg1;
  arg1 = (RobotRaconteur::IntraTransport *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WallTimer_initstruct_handler_set(void * jarg1, void * jarg2) {
  WallTimer_initstruct *arg1 = (WallTimer_initstruct *) 0 ;
  RobotRaconteur::AsyncTimerEventReturnDirector *arg2 = (RobotRaconteur::AsyncTimerEventReturnDirector *) 0 ;
  
  arg1 = (WallTimer_initstruct *)jarg1; 
  arg2 = (RobotRaconteur::AsyncTimerEventReturnDirector *)jarg2; 
  if (arg1) (arg1)->handler = arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WallTimer_initstruct_handler_get(void * jarg1) {
  void * jresult ;
  WallTimer_initstruct *arg1 = (WallTimer_initstruct *) 0 ;
  RobotRaconteur::AsyncTimerEventReturnDirector *result = 0 ;
  
  arg1 = (WallTimer_initstruct *)jarg1; 
  result = (RobotRaconteur::AsyncTimerEventReturnDirector *) ((arg1)->handler);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WallTimer_initstruct_id_set(void * jarg1, int jarg2) {
  WallTimer_initstruct *arg1 = (WallTimer_initstruct *) 0 ;
  int32_t arg2 ;
  
  arg1 = (WallTimer_initstruct *)jarg1; 
  arg2 = (int32_t)jarg2; 
  if (arg1) (arg1)->id = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WallTimer_initstruct_id_get(void * jarg1) {
  int jresult ;
  WallTimer_initstruct *arg1 = (WallTimer_initstruct *) 0 ;
  int32_t result;
  
  arg1 = (WallTimer_initstruct *)jarg1; 
  result = (int32_t) ((arg1)->id);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WallTimer_initstruct() {
  void * jresult ;
  WallTimer_initstruct *result = 0 ;
  
  
  try {
    result = (WallTimer_initstruct *)new WallTimer_initstruct();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WallTimer_initstruct(void * jarg1) {
  WallTimer_initstruct *arg1 = (WallTimer_initstruct *) 0 ;
  
  arg1 = (WallTimer_initstruct *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TimerEvent_stopped_get(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::TimerEvent *arg1 = (RobotRaconteur::TimerEvent *) 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::TimerEvent *)jarg1; 
  result = (bool) ((arg1)->stopped);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int64_t SWIGSTDCALL CSharp_RobotRaconteur_TimerEvent_last_expected_get(void * jarg1) {
  int64_t jresult ;
  RobotRaconteur::TimerEvent *arg1 = (RobotRaconteur::TimerEvent *) 0 ;
  boost::posix_time::ptime result;
  
  arg1 = (RobotRaconteur::TimerEvent *)jarg1; 
  result =  ((arg1)->last_expected);
  {
    {
      boost::posix_time::time_duration ptime_diff = (result - boost::posix_time::ptime(boost::gregorian::date(1970,1,1),boost::posix_time::time_duration(0,0,0)));
      jresult=ptime_diff.total_microseconds()*10;
    }
  }
  return jresult;
}


SWIGEXPORT int64_t SWIGSTDCALL CSharp_RobotRaconteur_TimerEvent_last_real_get(void * jarg1) {
  int64_t jresult ;
  RobotRaconteur::TimerEvent *arg1 = (RobotRaconteur::TimerEvent *) 0 ;
  boost::posix_time::ptime result;
  
  arg1 = (RobotRaconteur::TimerEvent *)jarg1; 
  result =  ((arg1)->last_real);
  {
    {
      boost::posix_time::time_duration ptime_diff = (result - boost::posix_time::ptime(boost::gregorian::date(1970,1,1),boost::posix_time::time_duration(0,0,0)));
      jresult=ptime_diff.total_microseconds()*10;
    }
  }
  return jresult;
}


SWIGEXPORT int64_t SWIGSTDCALL CSharp_RobotRaconteur_TimerEvent_current_expected_get(void * jarg1) {
  int64_t jresult ;
  RobotRaconteur::TimerEvent *arg1 = (RobotRaconteur::TimerEvent *) 0 ;
  boost::posix_time::ptime result;
  
  arg1 = (RobotRaconteur::TimerEvent *)jarg1; 
  result =  ((arg1)->current_expected);
  {
    {
      boost::posix_time::time_duration ptime_diff = (result - boost::posix_time::ptime(boost::gregorian::date(1970,1,1),boost::posix_time::time_duration(0,0,0)));
      jresult=ptime_diff.total_microseconds()*10;
    }
  }
  return jresult;
}


SWIGEXPORT int64_t SWIGSTDCALL CSharp_RobotRaconteur_TimerEvent_current_real_get(void * jarg1) {
  int64_t jresult ;
  RobotRaconteur::TimerEvent *arg1 = (RobotRaconteur::TimerEvent *) 0 ;
  boost::posix_time::ptime result;
  
  arg1 = (RobotRaconteur::TimerEvent *)jarg1; 
  result =  ((arg1)->current_real);
  {
    {
      boost::posix_time::time_duration ptime_diff = (result - boost::posix_time::ptime(boost::gregorian::date(1970,1,1),boost::posix_time::time_duration(0,0,0)));
      jresult=ptime_diff.total_microseconds()*10;
    }
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_TimerEvent() {
  void * jresult ;
  RobotRaconteur::TimerEvent *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::TimerEvent *)new RobotRaconteur::TimerEvent();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_TimerEvent(void * jarg1) {
  RobotRaconteur::TimerEvent *arg1 = (RobotRaconteur::TimerEvent *) 0 ;
  
  arg1 = (RobotRaconteur::TimerEvent *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_AsyncTimerEventReturnDirector(void * jarg1) {
  RobotRaconteur::AsyncTimerEventReturnDirector *arg1 = (RobotRaconteur::AsyncTimerEventReturnDirector *) 0 ;
  
  arg1 = (RobotRaconteur::AsyncTimerEventReturnDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AsyncTimerEventReturnDirector_handler(void * jarg1, void * jarg2, void * jarg3) {
  RobotRaconteur::AsyncTimerEventReturnDirector *arg1 = (RobotRaconteur::AsyncTimerEventReturnDirector *) 0 ;
  RobotRaconteur::TimerEvent *arg2 = 0 ;
  RobotRaconteur::HandlerErrorInfo *arg3 = 0 ;
  
  arg1 = (RobotRaconteur::AsyncTimerEventReturnDirector *)jarg1; 
  arg2 = (RobotRaconteur::TimerEvent *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::TimerEvent const & type is null", 0);
    return ;
  } 
  arg3 = (RobotRaconteur::HandlerErrorInfo *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::HandlerErrorInfo & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->handler((RobotRaconteur::TimerEvent const &)*arg2,*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_AsyncTimerEventReturnDirector() {
  void * jresult ;
  RobotRaconteur::AsyncTimerEventReturnDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::AsyncTimerEventReturnDirector *)new SwigDirector_AsyncTimerEventReturnDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AsyncTimerEventReturnDirector_director_connect(void *objarg, SwigDirector_AsyncTimerEventReturnDirector::SWIG_Callback0_t callback0) {
  RobotRaconteur::AsyncTimerEventReturnDirector *obj = (RobotRaconteur::AsyncTimerEventReturnDirector *)objarg;
  SwigDirector_AsyncTimerEventReturnDirector *director = static_cast<SwigDirector_AsyncTimerEventReturnDirector *>(obj);
  director->swig_connect_director(callback0);
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_Timer_Start(void * jarg1) {
  RobotRaconteur::Timer *arg1 = (RobotRaconteur::Timer *) 0 ;
  boost::shared_ptr< RobotRaconteur::Timer > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::Timer > *)jarg1;
  arg1 = (RobotRaconteur::Timer *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->Start();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_Timer_Stop(void * jarg1) {
  RobotRaconteur::Timer *arg1 = (RobotRaconteur::Timer *) 0 ;
  boost::shared_ptr< RobotRaconteur::Timer > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::Timer > *)jarg1;
  arg1 = (RobotRaconteur::Timer *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->Stop();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_Timer_TryStop(void * jarg1) {
  RobotRaconteur::Timer *arg1 = (RobotRaconteur::Timer *) 0 ;
  boost::shared_ptr< RobotRaconteur::Timer > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::Timer > *)jarg1;
  arg1 = (RobotRaconteur::Timer *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->TryStop();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT int32_t SWIGSTDCALL CSharp_RobotRaconteur_Timer_GetPeriod(void * jarg1) {
  int32_t jresult ;
  RobotRaconteur::Timer *arg1 = (RobotRaconteur::Timer *) 0 ;
  boost::shared_ptr< RobotRaconteur::Timer > *smartarg1 = 0 ;
  boost::posix_time::time_duration result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::Timer > *)jarg1;
  arg1 = (RobotRaconteur::Timer *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetPeriod();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  {
    jresult=(int32_t)(&result)->total_milliseconds();
  }
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_Timer_SetPeriod(void * jarg1, int32_t jarg2) {
  RobotRaconteur::Timer *arg1 = (RobotRaconteur::Timer *) 0 ;
  boost::posix_time::time_duration *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::Timer > *smartarg1 = 0 ;
  boost::posix_time::time_duration tmpDur2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::Timer > *)jarg1;
  arg1 = (RobotRaconteur::Timer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    tmpDur2=boost::posix_time::milliseconds(jarg2);
    arg2=&tmpDur2;
  }
  
  try {
    (arg1)->SetPeriod((boost::posix_time::time_duration const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_Timer_IsRunning(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::Timer *arg1 = (RobotRaconteur::Timer *) 0 ;
  boost::shared_ptr< RobotRaconteur::Timer > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::Timer > *)jarg1;
  arg1 = (RobotRaconteur::Timer *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->IsRunning();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_Timer(void * jarg1) {
  RobotRaconteur::Timer *arg1 = (RobotRaconteur::Timer *) 0 ;
  boost::shared_ptr< RobotRaconteur::Timer > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::Timer > *)jarg1;
  arg1 = (RobotRaconteur::Timer *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WallTimer_Start(void * jarg1) {
  RobotRaconteur::WallTimer *arg1 = (RobotRaconteur::WallTimer *) 0 ;
  boost::shared_ptr< RobotRaconteur::WallTimer > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WallTimer > *)jarg1;
  arg1 = (RobotRaconteur::WallTimer *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->Start();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WallTimer_Stop(void * jarg1) {
  RobotRaconteur::WallTimer *arg1 = (RobotRaconteur::WallTimer *) 0 ;
  boost::shared_ptr< RobotRaconteur::WallTimer > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WallTimer > *)jarg1;
  arg1 = (RobotRaconteur::WallTimer *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->Stop();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WallTimer_TryStop(void * jarg1) {
  RobotRaconteur::WallTimer *arg1 = (RobotRaconteur::WallTimer *) 0 ;
  boost::shared_ptr< RobotRaconteur::WallTimer > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WallTimer > *)jarg1;
  arg1 = (RobotRaconteur::WallTimer *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->TryStop();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT int32_t SWIGSTDCALL CSharp_RobotRaconteur_WallTimer_GetPeriod(void * jarg1) {
  int32_t jresult ;
  RobotRaconteur::WallTimer *arg1 = (RobotRaconteur::WallTimer *) 0 ;
  boost::shared_ptr< RobotRaconteur::WallTimer > *smartarg1 = 0 ;
  boost::posix_time::time_duration result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WallTimer > *)jarg1;
  arg1 = (RobotRaconteur::WallTimer *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetPeriod();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  {
    jresult=(int32_t)(&result)->total_milliseconds();
  }
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WallTimer_SetPeriod(void * jarg1, int32_t jarg2) {
  RobotRaconteur::WallTimer *arg1 = (RobotRaconteur::WallTimer *) 0 ;
  boost::posix_time::time_duration *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WallTimer > *smartarg1 = 0 ;
  boost::posix_time::time_duration tmpDur2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WallTimer > *)jarg1;
  arg1 = (RobotRaconteur::WallTimer *)(smartarg1 ? smartarg1->get() : 0); 
  {
    tmpDur2=boost::posix_time::milliseconds(jarg2);
    arg2=&tmpDur2;
  }
  
  try {
    (arg1)->SetPeriod((boost::posix_time::time_duration const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WallTimer_IsRunning(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::WallTimer *arg1 = (RobotRaconteur::WallTimer *) 0 ;
  boost::shared_ptr< RobotRaconteur::WallTimer > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WallTimer > *)jarg1;
  arg1 = (RobotRaconteur::WallTimer *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->IsRunning();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WallTimer(void * jarg1) {
  RobotRaconteur::WallTimer *arg1 = (RobotRaconteur::WallTimer *) 0 ;
  boost::shared_ptr< RobotRaconteur::WallTimer > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WallTimer > *)jarg1;
  arg1 = (RobotRaconteur::WallTimer *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WallTimer(int32_t jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  boost::posix_time::time_duration *arg1 = 0 ;
  bool arg2 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg3 = 0 ;
  WallTimer_initstruct arg4 ;
  boost::posix_time::time_duration tmpDur1 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull3 ;
  WallTimer_initstruct *argp4 ;
  RobotRaconteur::WallTimer *result = 0 ;
  
  {
    tmpDur1=boost::posix_time::milliseconds(jarg1);
    arg1=&tmpDur1;
  }
  arg2 = jarg2 ? true : false; 
  arg3 = jarg3 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg3 : &tempnull3; 
  argp4 = (WallTimer_initstruct *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null WallTimer_initstruct", 0);
    return 0;
  }
  arg4 = *argp4; 
  
  try {
    result = (RobotRaconteur::WallTimer *)new_RobotRaconteur_WallTimer((boost::posix_time::time_duration const &)*arg1,arg2,(boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg3,arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::WallTimer >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_Rate_Sleep(void * jarg1) {
  RobotRaconteur::Rate *arg1 = (RobotRaconteur::Rate *) 0 ;
  boost::shared_ptr< RobotRaconteur::Rate > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::Rate > *)jarg1;
  arg1 = (RobotRaconteur::Rate *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->Sleep();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_Rate(void * jarg1) {
  RobotRaconteur::Rate *arg1 = (RobotRaconteur::Rate *) 0 ;
  boost::shared_ptr< RobotRaconteur::Rate > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::Rate > *)jarg1;
  arg1 = (RobotRaconteur::Rate *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WallRate__SWIG_0(double jarg1, void * jarg2) {
  void * jresult ;
  double arg1 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > arg2 ;
  RobotRaconteur::WallRate *result = 0 ;
  
  arg1 = (double)jarg1; 
  if (jarg2) arg2 = *(boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg2; 
  
  try {
    result = (RobotRaconteur::WallRate *)new RobotRaconteur::WallRate(arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::WallRate >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WallRate__SWIG_1(double jarg1) {
  void * jresult ;
  double arg1 ;
  RobotRaconteur::WallRate *result = 0 ;
  
  arg1 = (double)jarg1; 
  
  try {
    result = (RobotRaconteur::WallRate *)new RobotRaconteur::WallRate(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::WallRate >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WallRate_Sleep(void * jarg1) {
  RobotRaconteur::WallRate *arg1 = (RobotRaconteur::WallRate *) 0 ;
  boost::shared_ptr< RobotRaconteur::WallRate > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WallRate > *)jarg1;
  arg1 = (RobotRaconteur::WallRate *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->Sleep();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WallRate(void * jarg1) {
  RobotRaconteur::WallRate *arg1 = (RobotRaconteur::WallRate *) 0 ;
  boost::shared_ptr< RobotRaconteur::WallRate > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WallRate > *)jarg1;
  arg1 = (RobotRaconteur::WallRate *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_AutoResetEvent() {
  void * jresult ;
  RobotRaconteur::AutoResetEvent *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::AutoResetEvent *)new RobotRaconteur::AutoResetEvent();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::AutoResetEvent >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_AutoResetEvent(void * jarg1) {
  RobotRaconteur::AutoResetEvent *arg1 = (RobotRaconteur::AutoResetEvent *) 0 ;
  boost::shared_ptr< RobotRaconteur::AutoResetEvent > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::AutoResetEvent > *)jarg1;
  arg1 = (RobotRaconteur::AutoResetEvent *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AutoResetEvent_Set(void * jarg1) {
  RobotRaconteur::AutoResetEvent *arg1 = (RobotRaconteur::AutoResetEvent *) 0 ;
  boost::shared_ptr< RobotRaconteur::AutoResetEvent > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::AutoResetEvent > *)jarg1;
  arg1 = (RobotRaconteur::AutoResetEvent *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->Set();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AutoResetEvent_Reset(void * jarg1) {
  RobotRaconteur::AutoResetEvent *arg1 = (RobotRaconteur::AutoResetEvent *) 0 ;
  boost::shared_ptr< RobotRaconteur::AutoResetEvent > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::AutoResetEvent > *)jarg1;
  arg1 = (RobotRaconteur::AutoResetEvent *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->Reset();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AutoResetEvent_WaitOne__SWIG_0(void * jarg1) {
  RobotRaconteur::AutoResetEvent *arg1 = (RobotRaconteur::AutoResetEvent *) 0 ;
  boost::shared_ptr< RobotRaconteur::AutoResetEvent > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::AutoResetEvent > *)jarg1;
  arg1 = (RobotRaconteur::AutoResetEvent *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->WaitOne();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_AutoResetEvent_WaitOne__SWIG_1(void * jarg1, int jarg2) {
  unsigned int jresult ;
  RobotRaconteur::AutoResetEvent *arg1 = (RobotRaconteur::AutoResetEvent *) 0 ;
  int32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::AutoResetEvent > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::AutoResetEvent > *)jarg1;
  arg1 = (RobotRaconteur::AutoResetEvent *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  
  try {
    result = (bool)(arg1)->WaitOne(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TimeSpec_seconds_set(void * jarg1, long long jarg2) {
  RobotRaconteur::TimeSpec *arg1 = (RobotRaconteur::TimeSpec *) 0 ;
  int64_t arg2 ;
  
  arg1 = (RobotRaconteur::TimeSpec *)jarg1; 
  arg2 = (int64_t)jarg2; 
  if (arg1) (arg1)->seconds = arg2;
}


SWIGEXPORT long long SWIGSTDCALL CSharp_RobotRaconteur_TimeSpec_seconds_get(void * jarg1) {
  long long jresult ;
  RobotRaconteur::TimeSpec *arg1 = (RobotRaconteur::TimeSpec *) 0 ;
  int64_t result;
  
  arg1 = (RobotRaconteur::TimeSpec *)jarg1; 
  result = (int64_t) ((arg1)->seconds);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TimeSpec_nanoseconds_set(void * jarg1, int jarg2) {
  RobotRaconteur::TimeSpec *arg1 = (RobotRaconteur::TimeSpec *) 0 ;
  int32_t arg2 ;
  
  arg1 = (RobotRaconteur::TimeSpec *)jarg1; 
  arg2 = (int32_t)jarg2; 
  if (arg1) (arg1)->nanoseconds = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_TimeSpec_nanoseconds_get(void * jarg1) {
  int jresult ;
  RobotRaconteur::TimeSpec *arg1 = (RobotRaconteur::TimeSpec *) 0 ;
  int32_t result;
  
  arg1 = (RobotRaconteur::TimeSpec *)jarg1; 
  result = (int32_t) ((arg1)->nanoseconds);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_TimeSpec__SWIG_0() {
  void * jresult ;
  RobotRaconteur::TimeSpec *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::TimeSpec *)new RobotRaconteur::TimeSpec();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_TimeSpec__SWIG_1(long long jarg1, int jarg2) {
  void * jresult ;
  int64_t arg1 ;
  int32_t arg2 ;
  RobotRaconteur::TimeSpec *result = 0 ;
  
  arg1 = (int64_t)jarg1; 
  arg2 = (int32_t)jarg2; 
  
  try {
    result = (RobotRaconteur::TimeSpec *)new RobotRaconteur::TimeSpec(arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TimeSpec_eq(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::TimeSpec *arg1 = (RobotRaconteur::TimeSpec *) 0 ;
  RobotRaconteur::TimeSpec *arg2 = 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::TimeSpec *)jarg1; 
  arg2 = (RobotRaconteur::TimeSpec *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::TimeSpec const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)(arg1)->operator ==((RobotRaconteur::TimeSpec const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TimeSpec_ne(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::TimeSpec *arg1 = (RobotRaconteur::TimeSpec *) 0 ;
  RobotRaconteur::TimeSpec *arg2 = 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::TimeSpec *)jarg1; 
  arg2 = (RobotRaconteur::TimeSpec *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::TimeSpec const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)(arg1)->operator !=((RobotRaconteur::TimeSpec const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_TimeSpec_sub(void * jarg1, void * jarg2) {
  void * jresult ;
  RobotRaconteur::TimeSpec *arg1 = (RobotRaconteur::TimeSpec *) 0 ;
  RobotRaconteur::TimeSpec *arg2 = 0 ;
  RobotRaconteur::TimeSpec result;
  
  arg1 = (RobotRaconteur::TimeSpec *)jarg1; 
  arg2 = (RobotRaconteur::TimeSpec *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::TimeSpec const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (arg1)->operator -((RobotRaconteur::TimeSpec const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::TimeSpec((const RobotRaconteur::TimeSpec &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_TimeSpec_add(void * jarg1, void * jarg2) {
  void * jresult ;
  RobotRaconteur::TimeSpec *arg1 = (RobotRaconteur::TimeSpec *) 0 ;
  RobotRaconteur::TimeSpec *arg2 = 0 ;
  RobotRaconteur::TimeSpec result;
  
  arg1 = (RobotRaconteur::TimeSpec *)jarg1; 
  arg2 = (RobotRaconteur::TimeSpec *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::TimeSpec const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (arg1)->operator +((RobotRaconteur::TimeSpec const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::TimeSpec((const RobotRaconteur::TimeSpec &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TimeSpec_gt(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::TimeSpec *arg1 = (RobotRaconteur::TimeSpec *) 0 ;
  RobotRaconteur::TimeSpec *arg2 = 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::TimeSpec *)jarg1; 
  arg2 = (RobotRaconteur::TimeSpec *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::TimeSpec const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)(arg1)->operator >((RobotRaconteur::TimeSpec const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TimeSpec_ge(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::TimeSpec *arg1 = (RobotRaconteur::TimeSpec *) 0 ;
  RobotRaconteur::TimeSpec *arg2 = 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::TimeSpec *)jarg1; 
  arg2 = (RobotRaconteur::TimeSpec *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::TimeSpec const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)(arg1)->operator >=((RobotRaconteur::TimeSpec const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TimeSpec_lt(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::TimeSpec *arg1 = (RobotRaconteur::TimeSpec *) 0 ;
  RobotRaconteur::TimeSpec *arg2 = 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::TimeSpec *)jarg1; 
  arg2 = (RobotRaconteur::TimeSpec *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::TimeSpec const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)(arg1)->operator <((RobotRaconteur::TimeSpec const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TimeSpec_le(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::TimeSpec *arg1 = (RobotRaconteur::TimeSpec *) 0 ;
  RobotRaconteur::TimeSpec *arg2 = 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::TimeSpec *)jarg1; 
  arg2 = (RobotRaconteur::TimeSpec *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::TimeSpec const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)(arg1)->operator <=((RobotRaconteur::TimeSpec const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TimeSpec_cleanup_nanosecs(void * jarg1) {
  RobotRaconteur::TimeSpec *arg1 = (RobotRaconteur::TimeSpec *) 0 ;
  
  arg1 = (RobotRaconteur::TimeSpec *)jarg1; 
  
  try {
    (arg1)->cleanup_nanosecs();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_TimeSpec(void * jarg1) {
  RobotRaconteur::TimeSpec *arg1 = (RobotRaconteur::TimeSpec *) 0 ;
  
  arg1 = (RobotRaconteur::TimeSpec *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedService_typed_packet_packet_set(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedService_typed_packet *arg1 = (RobotRaconteur::WrappedService_typed_packet *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *arg2 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > temp2 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg2 ;
  
  arg1 = (RobotRaconteur::WrappedService_typed_packet *)jarg1; 
  
  // intrusive_ptr by reference
  if ( jarg2 ) {
    smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg2;
    temp2 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg2->get(), true);
    arg2 = &temp2;
  } else {
    arg2 = &tempnull2;
  }
  
  if (arg1) (arg1)->packet = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedService_typed_packet_packet_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedService_typed_packet *arg1 = (RobotRaconteur::WrappedService_typed_packet *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *result = 0 ;
  
  arg1 = (RobotRaconteur::WrappedService_typed_packet *)jarg1; 
  result = (boost::intrusive_ptr< RobotRaconteur::MessageElement > *) & ((arg1)->packet);
  
  if (*result) {
    intrusive_ptr_add_ref(result->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >(result->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedService_typed_packet_type_set(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedService_typed_packet *arg1 = (RobotRaconteur::WrappedService_typed_packet *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > tempnull2 ;
  
  arg1 = (RobotRaconteur::WrappedService_typed_packet *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::TypeDefinition > *)jarg2 : &tempnull2; 
  if (arg1) (arg1)->type = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedService_typed_packet_type_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedService_typed_packet *arg1 = (RobotRaconteur::WrappedService_typed_packet *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *result = 0 ;
  
  arg1 = (RobotRaconteur::WrappedService_typed_packet *)jarg1; 
  result = (boost::shared_ptr< RobotRaconteur::TypeDefinition > *) & ((arg1)->type);
  jresult = *result ? new boost::shared_ptr< RobotRaconteur::TypeDefinition >(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedService_typed_packet_stub_set(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedService_typed_packet *arg1 = (RobotRaconteur::WrappedService_typed_packet *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > tempnull2 ;
  
  arg1 = (RobotRaconteur::WrappedService_typed_packet *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *)jarg2 : &tempnull2; 
  if (arg1) (arg1)->stub = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedService_typed_packet_stub_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedService_typed_packet *arg1 = (RobotRaconteur::WrappedService_typed_packet *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *result = 0 ;
  
  arg1 = (RobotRaconteur::WrappedService_typed_packet *)jarg1; 
  result = (boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *) & ((arg1)->stub);
  jresult = *result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceStub >(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedService_typed_packet_client_set(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::WrappedService_typed_packet *arg1 = (RobotRaconteur::WrappedService_typed_packet *) 0 ;
  uint32_t arg2 ;
  
  arg1 = (RobotRaconteur::WrappedService_typed_packet *)jarg1; 
  arg2 = (uint32_t)jarg2; 
  if (arg1) (arg1)->client = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedService_typed_packet_client_get(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::WrappedService_typed_packet *arg1 = (RobotRaconteur::WrappedService_typed_packet *) 0 ;
  uint32_t result;
  
  arg1 = (RobotRaconteur::WrappedService_typed_packet *)jarg1; 
  result = (uint32_t) ((arg1)->client);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedService_typed_packet() {
  void * jresult ;
  RobotRaconteur::WrappedService_typed_packet *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedService_typed_packet *)new RobotRaconteur::WrappedService_typed_packet();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedService_typed_packet(void * jarg1) {
  RobotRaconteur::WrappedService_typed_packet *arg1 = (RobotRaconteur::WrappedService_typed_packet *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedService_typed_packet *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedPipeEndpointDirector(void * jarg1) {
  RobotRaconteur::WrappedPipeEndpointDirector *arg1 = (RobotRaconteur::WrappedPipeEndpointDirector *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedPipeEndpointDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeEndpointDirector_PipeEndpointClosedCallback(void * jarg1) {
  RobotRaconteur::WrappedPipeEndpointDirector *arg1 = (RobotRaconteur::WrappedPipeEndpointDirector *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedPipeEndpointDirector *)jarg1; 
  
  try {
    (arg1)->PipeEndpointClosedCallback();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeEndpointDirector_PacketReceivedEvent(void * jarg1) {
  RobotRaconteur::WrappedPipeEndpointDirector *arg1 = (RobotRaconteur::WrappedPipeEndpointDirector *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedPipeEndpointDirector *)jarg1; 
  
  try {
    (arg1)->PacketReceivedEvent();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeEndpointDirector_PacketAckReceivedEvent(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::WrappedPipeEndpointDirector *arg1 = (RobotRaconteur::WrappedPipeEndpointDirector *) 0 ;
  uint32_t arg2 ;
  
  arg1 = (RobotRaconteur::WrappedPipeEndpointDirector *)jarg1; 
  arg2 = (uint32_t)jarg2; 
  
  try {
    (arg1)->PacketAckReceivedEvent(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedPipeEndpointDirector() {
  void * jresult ;
  RobotRaconteur::WrappedPipeEndpointDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedPipeEndpointDirector *)new SwigDirector_WrappedPipeEndpointDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeEndpointDirector_director_connect(void *objarg, SwigDirector_WrappedPipeEndpointDirector::SWIG_Callback0_t callback0, SwigDirector_WrappedPipeEndpointDirector::SWIG_Callback1_t callback1, SwigDirector_WrappedPipeEndpointDirector::SWIG_Callback2_t callback2) {
  RobotRaconteur::WrappedPipeEndpointDirector *obj = (RobotRaconteur::WrappedPipeEndpointDirector *)objarg;
  SwigDirector_WrappedPipeEndpointDirector *director = static_cast<SwigDirector_WrappedPipeEndpointDirector *>(obj);
  director->swig_connect_director(callback0, callback1, callback2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_AsyncPipeEndpointReturnDirector(void * jarg1) {
  RobotRaconteur::AsyncPipeEndpointReturnDirector *arg1 = (RobotRaconteur::AsyncPipeEndpointReturnDirector *) 0 ;
  
  arg1 = (RobotRaconteur::AsyncPipeEndpointReturnDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AsyncPipeEndpointReturnDirector_handler(void * jarg1, void * jarg2, void * jarg3) {
  RobotRaconteur::AsyncPipeEndpointReturnDirector *arg1 = (RobotRaconteur::AsyncPipeEndpointReturnDirector *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *arg2 = 0 ;
  RobotRaconteur::HandlerErrorInfo *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > tempnull2 ;
  
  arg1 = (RobotRaconteur::AsyncPipeEndpointReturnDirector *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *)jarg2 : &tempnull2; 
  arg3 = (RobotRaconteur::HandlerErrorInfo *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::HandlerErrorInfo & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->handler((boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > const &)*arg2,*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_AsyncPipeEndpointReturnDirector() {
  void * jresult ;
  RobotRaconteur::AsyncPipeEndpointReturnDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::AsyncPipeEndpointReturnDirector *)new SwigDirector_AsyncPipeEndpointReturnDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AsyncPipeEndpointReturnDirector_director_connect(void *objarg, SwigDirector_AsyncPipeEndpointReturnDirector::SWIG_Callback0_t callback0) {
  RobotRaconteur::AsyncPipeEndpointReturnDirector *obj = (RobotRaconteur::AsyncPipeEndpointReturnDirector *)objarg;
  SwigDirector_AsyncPipeEndpointReturnDirector *director = static_cast<SwigDirector_AsyncPipeEndpointReturnDirector *>(obj);
  director->swig_connect_director(callback0);
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedTryReceivePacketWaitResult_res_set(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::WrappedTryReceivePacketWaitResult *arg1 = (RobotRaconteur::WrappedTryReceivePacketWaitResult *) 0 ;
  bool arg2 ;
  
  arg1 = (RobotRaconteur::WrappedTryReceivePacketWaitResult *)jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->res = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedTryReceivePacketWaitResult_res_get(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::WrappedTryReceivePacketWaitResult *arg1 = (RobotRaconteur::WrappedTryReceivePacketWaitResult *) 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::WrappedTryReceivePacketWaitResult *)jarg1; 
  result = (bool) ((arg1)->res);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedTryReceivePacketWaitResult_packet_set(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedTryReceivePacketWaitResult *arg1 = (RobotRaconteur::WrappedTryReceivePacketWaitResult *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *arg2 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > temp2 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg2 ;
  
  arg1 = (RobotRaconteur::WrappedTryReceivePacketWaitResult *)jarg1; 
  
  // intrusive_ptr by reference
  if ( jarg2 ) {
    smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg2;
    temp2 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg2->get(), true);
    arg2 = &temp2;
  } else {
    arg2 = &tempnull2;
  }
  
  if (arg1) (arg1)->packet = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedTryReceivePacketWaitResult_packet_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedTryReceivePacketWaitResult *arg1 = (RobotRaconteur::WrappedTryReceivePacketWaitResult *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *result = 0 ;
  
  arg1 = (RobotRaconteur::WrappedTryReceivePacketWaitResult *)jarg1; 
  result = (boost::intrusive_ptr< RobotRaconteur::MessageElement > *) & ((arg1)->packet);
  
  if (*result) {
    intrusive_ptr_add_ref(result->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >(result->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedTryReceivePacketWaitResult() {
  void * jresult ;
  RobotRaconteur::WrappedTryReceivePacketWaitResult *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedTryReceivePacketWaitResult *)new RobotRaconteur::WrappedTryReceivePacketWaitResult();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedTryReceivePacketWaitResult(void * jarg1) {
  RobotRaconteur::WrappedTryReceivePacketWaitResult *arg1 = (RobotRaconteur::WrappedTryReceivePacketWaitResult *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedTryReceivePacketWaitResult *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeEndpoint_SendPacket(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::WrappedPipeEndpoint *arg1 = (RobotRaconteur::WrappedPipeEndpoint *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > temp2 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg2 ;
  uint32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeEndpoint > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeEndpoint *)(smartarg1 ? smartarg1->get() : 0); 
  
  // intrusive_ptr by reference
  if ( jarg2 ) {
    smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg2;
    temp2 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg2->get(), true);
    arg2 = &temp2;
  } else {
    arg2 = &tempnull2;
  }
  
  
  try {
    result = (uint32_t)(arg1)->SendPacket((boost::intrusive_ptr< RobotRaconteur::MessageElement > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeEndpoint_ReceivePacket(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedPipeEndpoint *arg1 = (RobotRaconteur::WrappedPipeEndpoint *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeEndpoint > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeEndpoint *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->ReceivePacket();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeEndpoint_PeekNextPacket(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedPipeEndpoint *arg1 = (RobotRaconteur::WrappedPipeEndpoint *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeEndpoint > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeEndpoint *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->PeekNextPacket();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeEndpoint_ReceivePacketWait__SWIG_0(void * jarg1, int jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedPipeEndpoint *arg1 = (RobotRaconteur::WrappedPipeEndpoint *) 0 ;
  int32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeEndpoint > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeEndpoint *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  
  try {
    result = (arg1)->ReceivePacketWait(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeEndpoint_ReceivePacketWait__SWIG_1(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedPipeEndpoint *arg1 = (RobotRaconteur::WrappedPipeEndpoint *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeEndpoint > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeEndpoint *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->ReceivePacketWait();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeEndpoint_PeekNextPacketWait__SWIG_0(void * jarg1, int jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedPipeEndpoint *arg1 = (RobotRaconteur::WrappedPipeEndpoint *) 0 ;
  int32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeEndpoint > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeEndpoint *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  
  try {
    result = (arg1)->PeekNextPacketWait(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeEndpoint_PeekNextPacketWait__SWIG_1(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedPipeEndpoint *arg1 = (RobotRaconteur::WrappedPipeEndpoint *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeEndpoint > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeEndpoint *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->PeekNextPacketWait();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeEndpoint_TryReceivePacketWait__SWIG_0(void * jarg1, int jarg2, unsigned int jarg3) {
  void * jresult ;
  RobotRaconteur::WrappedPipeEndpoint *arg1 = (RobotRaconteur::WrappedPipeEndpoint *) 0 ;
  int32_t arg2 ;
  bool arg3 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *smartarg1 = 0 ;
  RobotRaconteur::WrappedTryReceivePacketWaitResult result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeEndpoint > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeEndpoint *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  arg3 = jarg3 ? true : false; 
  
  try {
    result = (arg1)->TryReceivePacketWait(arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::WrappedTryReceivePacketWaitResult((const RobotRaconteur::WrappedTryReceivePacketWaitResult &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeEndpoint_TryReceivePacketWait__SWIG_1(void * jarg1, int jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedPipeEndpoint *arg1 = (RobotRaconteur::WrappedPipeEndpoint *) 0 ;
  int32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *smartarg1 = 0 ;
  RobotRaconteur::WrappedTryReceivePacketWaitResult result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeEndpoint > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeEndpoint *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  
  try {
    result = (arg1)->TryReceivePacketWait(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::WrappedTryReceivePacketWaitResult((const RobotRaconteur::WrappedTryReceivePacketWaitResult &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeEndpoint_TryReceivePacketWait__SWIG_2(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedPipeEndpoint *arg1 = (RobotRaconteur::WrappedPipeEndpoint *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *smartarg1 = 0 ;
  RobotRaconteur::WrappedTryReceivePacketWaitResult result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeEndpoint > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeEndpoint *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->TryReceivePacketWait();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::WrappedTryReceivePacketWaitResult((const RobotRaconteur::WrappedTryReceivePacketWaitResult &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeEndpoint_Close(void * jarg1) {
  RobotRaconteur::WrappedPipeEndpoint *arg1 = (RobotRaconteur::WrappedPipeEndpoint *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeEndpoint > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeEndpoint *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->Close();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeEndpoint_GetIndex(void * jarg1) {
  int jresult ;
  RobotRaconteur::WrappedPipeEndpoint *arg1 = (RobotRaconteur::WrappedPipeEndpoint *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *smartarg1 = 0 ;
  int32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeEndpoint > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeEndpoint *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (int32_t)(arg1)->GetIndex();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeEndpoint_GetEndpoint(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::WrappedPipeEndpoint *arg1 = (RobotRaconteur::WrappedPipeEndpoint *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *smartarg1 = 0 ;
  uint32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeEndpoint > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeEndpoint *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (uint32_t)(arg1)->GetEndpoint();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeEndpoint_Available(void * jarg1) {
  unsigned long jresult ;
  RobotRaconteur::WrappedPipeEndpoint *arg1 = (RobotRaconteur::WrappedPipeEndpoint *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *smartarg1 = 0 ;
  size_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeEndpoint > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeEndpoint *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->Available();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeEndpoint_GetRequestPacketAck(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::WrappedPipeEndpoint *arg1 = (RobotRaconteur::WrappedPipeEndpoint *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeEndpoint > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeEndpoint *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->GetRequestPacketAck();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeEndpoint_SetRequestPacketAck(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::WrappedPipeEndpoint *arg1 = (RobotRaconteur::WrappedPipeEndpoint *) 0 ;
  bool arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeEndpoint > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeEndpoint *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? true : false; 
  
  try {
    (arg1)->SetRequestPacketAck(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeEndpoint_Type_set(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedPipeEndpoint *arg1 = (RobotRaconteur::WrappedPipeEndpoint *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeEndpoint > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeEndpoint *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::TypeDefinition > *)jarg2 : &tempnull2; 
  if (arg1) (arg1)->Type = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeEndpoint_Type_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedPipeEndpoint *arg1 = (RobotRaconteur::WrappedPipeEndpoint *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeEndpoint > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeEndpoint *)(smartarg1 ? smartarg1->get() : 0); 
  result = (boost::shared_ptr< RobotRaconteur::TypeDefinition > *) & ((arg1)->Type);
  jresult = *result ? new boost::shared_ptr< RobotRaconteur::TypeDefinition >(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeEndpoint_SetRRDirector(void * jarg1, void * jarg2, int jarg3) {
  RobotRaconteur::WrappedPipeEndpoint *arg1 = (RobotRaconteur::WrappedPipeEndpoint *) 0 ;
  RobotRaconteur::WrappedPipeEndpointDirector *arg2 = (RobotRaconteur::WrappedPipeEndpointDirector *) 0 ;
  int32_t arg3 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeEndpoint > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeEndpoint *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::WrappedPipeEndpointDirector *)jarg2; 
  arg3 = (int32_t)jarg3; 
  
  try {
    (arg1)->SetRRDirector(arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeEndpoint_IsUnreliable(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::WrappedPipeEndpoint *arg1 = (RobotRaconteur::WrappedPipeEndpoint *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeEndpoint > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeEndpoint *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->IsUnreliable();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeEndpoint_Direction(void * jarg1) {
  int jresult ;
  RobotRaconteur::WrappedPipeEndpoint *arg1 = (RobotRaconteur::WrappedPipeEndpoint *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *smartarg1 = 0 ;
  RobotRaconteur::MemberDefinition_Direction result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeEndpoint > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeEndpoint *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (RobotRaconteur::MemberDefinition_Direction)(arg1)->Direction();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeEndpoint_AsyncSendPacket(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
  RobotRaconteur::WrappedPipeEndpoint *arg1 = (RobotRaconteur::WrappedPipeEndpoint *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *arg2 = 0 ;
  RobotRaconteur::AsyncUInt32ReturnDirector *arg3 = (RobotRaconteur::AsyncUInt32ReturnDirector *) 0 ;
  int32_t arg4 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > temp2 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeEndpoint > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeEndpoint *)(smartarg1 ? smartarg1->get() : 0); 
  
  // intrusive_ptr by reference
  if ( jarg2 ) {
    smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg2;
    temp2 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg2->get(), true);
    arg2 = &temp2;
  } else {
    arg2 = &tempnull2;
  }
  
  arg3 = (RobotRaconteur::AsyncUInt32ReturnDirector *)jarg3; 
  arg4 = (int32_t)jarg4; 
  
  try {
    (arg1)->AsyncSendPacket((boost::intrusive_ptr< RobotRaconteur::MessageElement > const &)*arg2,arg3,arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeEndpoint_AsyncClose(void * jarg1, int jarg2, void * jarg3, int jarg4) {
  RobotRaconteur::WrappedPipeEndpoint *arg1 = (RobotRaconteur::WrappedPipeEndpoint *) 0 ;
  int32_t arg2 ;
  RobotRaconteur::AsyncVoidReturnDirector *arg3 = (RobotRaconteur::AsyncVoidReturnDirector *) 0 ;
  int32_t arg4 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeEndpoint > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeEndpoint *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  arg3 = (RobotRaconteur::AsyncVoidReturnDirector *)jarg3; 
  arg4 = (int32_t)jarg4; 
  
  try {
    (arg1)->AsyncClose(arg2,arg3,arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeEndpoint_GetNode(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedPipeEndpoint *arg1 = (RobotRaconteur::WrappedPipeEndpoint *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeEndpoint > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeEndpoint *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetNode();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::RobotRaconteurNode >(result) : 0; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeEndpoint_GetIgnoreReceived(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::WrappedPipeEndpoint *arg1 = (RobotRaconteur::WrappedPipeEndpoint *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeEndpoint > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeEndpoint *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->GetIgnoreReceived();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeEndpoint_SetIgnoreReceived(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::WrappedPipeEndpoint *arg1 = (RobotRaconteur::WrappedPipeEndpoint *) 0 ;
  bool arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeEndpoint > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeEndpoint *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? true : false; 
  
  try {
    (arg1)->SetIgnoreReceived(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedPipeEndpoint(void * jarg1) {
  RobotRaconteur::WrappedPipeEndpoint *arg1 = (RobotRaconteur::WrappedPipeEndpoint *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeEndpoint > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeEndpoint *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeClient_Connect(void * jarg1, int jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedPipeClient *arg1 = (RobotRaconteur::WrappedPipeClient *) 0 ;
  int32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeClient > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeClient *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  
  try {
    result = (arg1)->Connect(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeClient_AsyncConnect(void * jarg1, int jarg2, int jarg3, void * jarg4, int jarg5) {
  RobotRaconteur::WrappedPipeClient *arg1 = (RobotRaconteur::WrappedPipeClient *) 0 ;
  int32_t arg2 ;
  int32_t arg3 ;
  RobotRaconteur::AsyncPipeEndpointReturnDirector *arg4 = (RobotRaconteur::AsyncPipeEndpointReturnDirector *) 0 ;
  int32_t arg5 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeClient > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeClient *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  arg3 = (int32_t)jarg3; 
  arg4 = (RobotRaconteur::AsyncPipeEndpointReturnDirector *)jarg4; 
  arg5 = (int32_t)jarg5; 
  
  try {
    (arg1)->AsyncConnect(arg2,arg3,arg4,arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeClient_GetMemberName(void * jarg1) {
  char * jresult ;
  RobotRaconteur::WrappedPipeClient *arg1 = (RobotRaconteur::WrappedPipeClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeClient > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetMemberName();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeClient_Type_set(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedPipeClient *arg1 = (RobotRaconteur::WrappedPipeClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeClient > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeClient *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::TypeDefinition > *)jarg2 : &tempnull2; 
  if (arg1) (arg1)->Type = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeClient_Type_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedPipeClient *arg1 = (RobotRaconteur::WrappedPipeClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeClient > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeClient *)(smartarg1 ? smartarg1->get() : 0); 
  result = (boost::shared_ptr< RobotRaconteur::TypeDefinition > *) & ((arg1)->Type);
  jresult = *result ? new boost::shared_ptr< RobotRaconteur::TypeDefinition >(*result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeClient_GetNode(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedPipeClient *arg1 = (RobotRaconteur::WrappedPipeClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeClient > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetNode();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::RobotRaconteurNode >(result) : 0; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeClient_Direction(void * jarg1) {
  int jresult ;
  RobotRaconteur::WrappedPipeClient *arg1 = (RobotRaconteur::WrappedPipeClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeClient > *smartarg1 = 0 ;
  RobotRaconteur::MemberDefinition_Direction result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (RobotRaconteur::MemberDefinition_Direction)(arg1)->Direction();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedPipeClient(void * jarg1) {
  RobotRaconteur::WrappedPipeClient *arg1 = (RobotRaconteur::WrappedPipeClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeClient > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedPipeServerConnectDirector(void * jarg1) {
  RobotRaconteur::WrappedPipeServerConnectDirector *arg1 = (RobotRaconteur::WrappedPipeServerConnectDirector *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedPipeServerConnectDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeServerConnectDirector_PipeConnectCallback(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedPipeServerConnectDirector *arg1 = (RobotRaconteur::WrappedPipeServerConnectDirector *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > tempnull2 ;
  
  arg1 = (RobotRaconteur::WrappedPipeServerConnectDirector *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > *)jarg2 : &tempnull2; 
  
  try {
    (arg1)->PipeConnectCallback((boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedPipeServerConnectDirector() {
  void * jresult ;
  RobotRaconteur::WrappedPipeServerConnectDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedPipeServerConnectDirector *)new SwigDirector_WrappedPipeServerConnectDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeServerConnectDirector_director_connect(void *objarg, SwigDirector_WrappedPipeServerConnectDirector::SWIG_Callback0_t callback0) {
  RobotRaconteur::WrappedPipeServerConnectDirector *obj = (RobotRaconteur::WrappedPipeServerConnectDirector *)objarg;
  SwigDirector_WrappedPipeServerConnectDirector *director = static_cast<SwigDirector_WrappedPipeServerConnectDirector *>(obj);
  director->swig_connect_director(callback0);
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeServer_GetMemberName(void * jarg1) {
  char * jresult ;
  RobotRaconteur::WrappedPipeServer *arg1 = (RobotRaconteur::WrappedPipeServer *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeServer > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeServer > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeServer *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetMemberName();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeServer_Type_set(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedPipeServer *arg1 = (RobotRaconteur::WrappedPipeServer *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeServer > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeServer > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeServer *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::TypeDefinition > *)jarg2 : &tempnull2; 
  if (arg1) (arg1)->Type = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeServer_Type_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedPipeServer *arg1 = (RobotRaconteur::WrappedPipeServer *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeServer > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeServer > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeServer *)(smartarg1 ? smartarg1->get() : 0); 
  result = (boost::shared_ptr< RobotRaconteur::TypeDefinition > *) & ((arg1)->Type);
  jresult = *result ? new boost::shared_ptr< RobotRaconteur::TypeDefinition >(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeServer_SetWrappedPipeConnectCallback(void * jarg1, void * jarg2, int jarg3) {
  RobotRaconteur::WrappedPipeServer *arg1 = (RobotRaconteur::WrappedPipeServer *) 0 ;
  RobotRaconteur::WrappedPipeServerConnectDirector *arg2 = (RobotRaconteur::WrappedPipeServerConnectDirector *) 0 ;
  int32_t arg3 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeServer > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeServer > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeServer *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::WrappedPipeServerConnectDirector *)jarg2; 
  arg3 = (int32_t)jarg3; 
  
  try {
    (arg1)->SetWrappedPipeConnectCallback(arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeServer_GetNode(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedPipeServer *arg1 = (RobotRaconteur::WrappedPipeServer *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeServer > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeServer > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeServer *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetNode();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::RobotRaconteurNode >(result) : 0; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeServer_Direction(void * jarg1) {
  int jresult ;
  RobotRaconteur::WrappedPipeServer *arg1 = (RobotRaconteur::WrappedPipeServer *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeServer > *smartarg1 = 0 ;
  RobotRaconteur::MemberDefinition_Direction result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeServer > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeServer *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (RobotRaconteur::MemberDefinition_Direction)(arg1)->Direction();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedPipeServer(void * jarg1) {
  RobotRaconteur::WrappedPipeServer *arg1 = (RobotRaconteur::WrappedPipeServer *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeServer > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeServer > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeServer *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeBroadcasterPredicateDirector_Predicate(void * jarg1, unsigned int jarg2, int jarg3) {
  unsigned int jresult ;
  RobotRaconteur::WrappedPipeBroadcasterPredicateDirector *arg1 = (RobotRaconteur::WrappedPipeBroadcasterPredicateDirector *) 0 ;
  uint32_t arg2 ;
  int32_t arg3 ;
  bool result;
  
  arg1 = (RobotRaconteur::WrappedPipeBroadcasterPredicateDirector *)jarg1; 
  arg2 = (uint32_t)jarg2; 
  arg3 = (int32_t)jarg3; 
  
  try {
    result = (bool)(arg1)->Predicate(arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedPipeBroadcasterPredicateDirector(void * jarg1) {
  RobotRaconteur::WrappedPipeBroadcasterPredicateDirector *arg1 = (RobotRaconteur::WrappedPipeBroadcasterPredicateDirector *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedPipeBroadcasterPredicateDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedPipeBroadcasterPredicateDirector() {
  void * jresult ;
  RobotRaconteur::WrappedPipeBroadcasterPredicateDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedPipeBroadcasterPredicateDirector *)new SwigDirector_WrappedPipeBroadcasterPredicateDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeBroadcasterPredicateDirector_director_connect(void *objarg, SwigDirector_WrappedPipeBroadcasterPredicateDirector::SWIG_Callback0_t callback0) {
  RobotRaconteur::WrappedPipeBroadcasterPredicateDirector *obj = (RobotRaconteur::WrappedPipeBroadcasterPredicateDirector *)objarg;
  SwigDirector_WrappedPipeBroadcasterPredicateDirector *director = static_cast<SwigDirector_WrappedPipeBroadcasterPredicateDirector *>(obj);
  director->swig_connect_director(callback0);
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeBroadcaster_Init__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
  RobotRaconteur::WrappedPipeBroadcaster *arg1 = (RobotRaconteur::WrappedPipeBroadcaster *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeServer > *arg2 = 0 ;
  int32_t arg3 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeBroadcaster > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeServer > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeBroadcaster > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeBroadcaster *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedPipeServer > *)jarg2 : &tempnull2; 
  arg3 = (int32_t)jarg3; 
  
  try {
    (arg1)->Init((boost::shared_ptr< RobotRaconteur::WrappedPipeServer > const &)*arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeBroadcaster_Init__SWIG_1(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedPipeBroadcaster *arg1 = (RobotRaconteur::WrappedPipeBroadcaster *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeServer > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeBroadcaster > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeServer > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeBroadcaster > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeBroadcaster *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedPipeServer > *)jarg2 : &tempnull2; 
  
  try {
    (arg1)->Init((boost::shared_ptr< RobotRaconteur::WrappedPipeServer > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeBroadcaster_SendPacket(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedPipeBroadcaster *arg1 = (RobotRaconteur::WrappedPipeBroadcaster *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeBroadcaster > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > temp2 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeBroadcaster > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeBroadcaster *)(smartarg1 ? smartarg1->get() : 0); 
  
  // intrusive_ptr by reference
  if ( jarg2 ) {
    smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg2;
    temp2 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg2->get(), true);
    arg2 = &temp2;
  } else {
    arg2 = &tempnull2;
  }
  
  
  try {
    (arg1)->SendPacket((boost::intrusive_ptr< RobotRaconteur::MessageElement > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeBroadcaster_AsyncSendPacket(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
  RobotRaconteur::WrappedPipeBroadcaster *arg1 = (RobotRaconteur::WrappedPipeBroadcaster *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *arg2 = 0 ;
  RobotRaconteur::AsyncVoidNoErrReturnDirector *arg3 = (RobotRaconteur::AsyncVoidNoErrReturnDirector *) 0 ;
  int32_t arg4 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeBroadcaster > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > temp2 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeBroadcaster > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeBroadcaster *)(smartarg1 ? smartarg1->get() : 0); 
  
  // intrusive_ptr by reference
  if ( jarg2 ) {
    smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg2;
    temp2 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg2->get(), true);
    arg2 = &temp2;
  } else {
    arg2 = &tempnull2;
  }
  
  arg3 = (RobotRaconteur::AsyncVoidNoErrReturnDirector *)jarg3; 
  arg4 = (int32_t)jarg4; 
  
  try {
    (arg1)->AsyncSendPacket((boost::intrusive_ptr< RobotRaconteur::MessageElement > const &)*arg2,arg3,arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeBroadcaster_GetActivePipeEndpointCount(void * jarg1) {
  unsigned long jresult ;
  RobotRaconteur::WrappedPipeBroadcaster *arg1 = (RobotRaconteur::WrappedPipeBroadcaster *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeBroadcaster > *smartarg1 = 0 ;
  size_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeBroadcaster > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeBroadcaster *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetActivePipeEndpointCount();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeBroadcaster_SetPredicateDirector(void * jarg1, void * jarg2, int jarg3) {
  RobotRaconteur::WrappedPipeBroadcaster *arg1 = (RobotRaconteur::WrappedPipeBroadcaster *) 0 ;
  RobotRaconteur::WrappedPipeBroadcasterPredicateDirector *arg2 = (RobotRaconteur::WrappedPipeBroadcasterPredicateDirector *) 0 ;
  int32_t arg3 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeBroadcaster > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeBroadcaster > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeBroadcaster *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::WrappedPipeBroadcasterPredicateDirector *)jarg2; 
  arg3 = (int32_t)jarg3; 
  
  try {
    (arg1)->SetPredicateDirector(arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeBroadcaster_GetMaxBacklog(void * jarg1) {
  int jresult ;
  RobotRaconteur::WrappedPipeBroadcaster *arg1 = (RobotRaconteur::WrappedPipeBroadcaster *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeBroadcaster > *smartarg1 = 0 ;
  int32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeBroadcaster > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeBroadcaster *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (int32_t)(arg1)->GetMaxBacklog();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeBroadcaster_SetMaxBacklog(void * jarg1, int jarg2) {
  RobotRaconteur::WrappedPipeBroadcaster *arg1 = (RobotRaconteur::WrappedPipeBroadcaster *) 0 ;
  int32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeBroadcaster > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeBroadcaster > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeBroadcaster *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  
  try {
    (arg1)->SetMaxBacklog(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedPipeBroadcaster() {
  void * jresult ;
  RobotRaconteur::WrappedPipeBroadcaster *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedPipeBroadcaster *)new RobotRaconteur::WrappedPipeBroadcaster();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::WrappedPipeBroadcaster >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedPipeBroadcaster(void * jarg1) {
  RobotRaconteur::WrappedPipeBroadcaster *arg1 = (RobotRaconteur::WrappedPipeBroadcaster *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeBroadcaster > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeBroadcaster > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeBroadcaster *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedWireConnectionDirector(void * jarg1) {
  RobotRaconteur::WrappedWireConnectionDirector *arg1 = (RobotRaconteur::WrappedWireConnectionDirector *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedWireConnectionDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireConnectionDirector_WireValueChanged(void * jarg1, void * jarg2, void * jarg3) {
  RobotRaconteur::WrappedWireConnectionDirector *arg1 = (RobotRaconteur::WrappedWireConnectionDirector *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > arg2 ;
  RobotRaconteur::TimeSpec *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg2 ;
  
  arg1 = (RobotRaconteur::WrappedWireConnectionDirector *)jarg1; 
  
  // intrusive_ptr by value
  smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg2;
  if (smartarg2) {
    arg2 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg2->get(), true);
  }
  
  arg3 = (RobotRaconteur::TimeSpec *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::TimeSpec const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->WireValueChanged(arg2,(RobotRaconteur::TimeSpec const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireConnectionDirector_WireConnectionClosedCallback(void * jarg1) {
  RobotRaconteur::WrappedWireConnectionDirector *arg1 = (RobotRaconteur::WrappedWireConnectionDirector *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedWireConnectionDirector *)jarg1; 
  
  try {
    (arg1)->WireConnectionClosedCallback();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedWireConnectionDirector() {
  void * jresult ;
  RobotRaconteur::WrappedWireConnectionDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedWireConnectionDirector *)new SwigDirector_WrappedWireConnectionDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireConnectionDirector_director_connect(void *objarg, SwigDirector_WrappedWireConnectionDirector::SWIG_Callback0_t callback0, SwigDirector_WrappedWireConnectionDirector::SWIG_Callback1_t callback1) {
  RobotRaconteur::WrappedWireConnectionDirector *obj = (RobotRaconteur::WrappedWireConnectionDirector *)objarg;
  SwigDirector_WrappedWireConnectionDirector *director = static_cast<SwigDirector_WrappedWireConnectionDirector *>(obj);
  director->swig_connect_director(callback0, callback1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_AsyncWireConnectionReturnDirector(void * jarg1) {
  RobotRaconteur::AsyncWireConnectionReturnDirector *arg1 = (RobotRaconteur::AsyncWireConnectionReturnDirector *) 0 ;
  
  arg1 = (RobotRaconteur::AsyncWireConnectionReturnDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AsyncWireConnectionReturnDirector_handler(void * jarg1, void * jarg2, void * jarg3) {
  RobotRaconteur::AsyncWireConnectionReturnDirector *arg1 = (RobotRaconteur::AsyncWireConnectionReturnDirector *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *arg2 = 0 ;
  RobotRaconteur::HandlerErrorInfo *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > tempnull2 ;
  
  arg1 = (RobotRaconteur::AsyncWireConnectionReturnDirector *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *)jarg2 : &tempnull2; 
  arg3 = (RobotRaconteur::HandlerErrorInfo *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::HandlerErrorInfo & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->handler((boost::shared_ptr< RobotRaconteur::WrappedWireConnection > const &)*arg2,*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_AsyncWireConnectionReturnDirector() {
  void * jresult ;
  RobotRaconteur::AsyncWireConnectionReturnDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::AsyncWireConnectionReturnDirector *)new SwigDirector_AsyncWireConnectionReturnDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AsyncWireConnectionReturnDirector_director_connect(void *objarg, SwigDirector_AsyncWireConnectionReturnDirector::SWIG_Callback0_t callback0) {
  RobotRaconteur::AsyncWireConnectionReturnDirector *obj = (RobotRaconteur::AsyncWireConnectionReturnDirector *)objarg;
  SwigDirector_AsyncWireConnectionReturnDirector *director = static_cast<SwigDirector_AsyncWireConnectionReturnDirector *>(obj);
  director->swig_connect_director(callback0);
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_AsyncWirePeekReturnDirector(void * jarg1) {
  RobotRaconteur::AsyncWirePeekReturnDirector *arg1 = (RobotRaconteur::AsyncWirePeekReturnDirector *) 0 ;
  
  arg1 = (RobotRaconteur::AsyncWirePeekReturnDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AsyncWirePeekReturnDirector_handler(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  RobotRaconteur::AsyncWirePeekReturnDirector *arg1 = (RobotRaconteur::AsyncWirePeekReturnDirector *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > arg2 ;
  RobotRaconteur::TimeSpec *arg3 = 0 ;
  RobotRaconteur::HandlerErrorInfo *arg4 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg2 ;
  
  arg1 = (RobotRaconteur::AsyncWirePeekReturnDirector *)jarg1; 
  
  // intrusive_ptr by value
  smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg2;
  if (smartarg2) {
    arg2 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg2->get(), true);
  }
  
  arg3 = (RobotRaconteur::TimeSpec *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::TimeSpec const & type is null", 0);
    return ;
  } 
  arg4 = (RobotRaconteur::HandlerErrorInfo *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::HandlerErrorInfo & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->handler(arg2,(RobotRaconteur::TimeSpec const &)*arg3,*arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_AsyncWirePeekReturnDirector() {
  void * jresult ;
  RobotRaconteur::AsyncWirePeekReturnDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::AsyncWirePeekReturnDirector *)new SwigDirector_AsyncWirePeekReturnDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AsyncWirePeekReturnDirector_director_connect(void *objarg, SwigDirector_AsyncWirePeekReturnDirector::SWIG_Callback0_t callback0) {
  RobotRaconteur::AsyncWirePeekReturnDirector *obj = (RobotRaconteur::AsyncWirePeekReturnDirector *)objarg;
  SwigDirector_AsyncWirePeekReturnDirector *director = static_cast<SwigDirector_AsyncWirePeekReturnDirector *>(obj);
  director->swig_connect_director(callback0);
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TryGetValueResult_res_set(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::TryGetValueResult *arg1 = (RobotRaconteur::TryGetValueResult *) 0 ;
  bool arg2 ;
  
  arg1 = (RobotRaconteur::TryGetValueResult *)jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->res = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_TryGetValueResult_res_get(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::TryGetValueResult *arg1 = (RobotRaconteur::TryGetValueResult *) 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::TryGetValueResult *)jarg1; 
  result = (bool) ((arg1)->res);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TryGetValueResult_value_set(void * jarg1, void * jarg2) {
  RobotRaconteur::TryGetValueResult *arg1 = (RobotRaconteur::TryGetValueResult *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *arg2 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > temp2 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg2 ;
  
  arg1 = (RobotRaconteur::TryGetValueResult *)jarg1; 
  
  // intrusive_ptr by reference
  if ( jarg2 ) {
    smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg2;
    temp2 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg2->get(), true);
    arg2 = &temp2;
  } else {
    arg2 = &tempnull2;
  }
  
  if (arg1) (arg1)->value = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_TryGetValueResult_value_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::TryGetValueResult *arg1 = (RobotRaconteur::TryGetValueResult *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *result = 0 ;
  
  arg1 = (RobotRaconteur::TryGetValueResult *)jarg1; 
  result = (boost::intrusive_ptr< RobotRaconteur::MessageElement > *) & ((arg1)->value);
  
  if (*result) {
    intrusive_ptr_add_ref(result->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >(result->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_TryGetValueResult_ts_set(void * jarg1, void * jarg2) {
  RobotRaconteur::TryGetValueResult *arg1 = (RobotRaconteur::TryGetValueResult *) 0 ;
  RobotRaconteur::TimeSpec *arg2 = (RobotRaconteur::TimeSpec *) 0 ;
  
  arg1 = (RobotRaconteur::TryGetValueResult *)jarg1; 
  arg2 = (RobotRaconteur::TimeSpec *)jarg2; 
  if (arg1) (arg1)->ts = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_TryGetValueResult_ts_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::TryGetValueResult *arg1 = (RobotRaconteur::TryGetValueResult *) 0 ;
  RobotRaconteur::TimeSpec *result = 0 ;
  
  arg1 = (RobotRaconteur::TryGetValueResult *)jarg1; 
  result = (RobotRaconteur::TimeSpec *)& ((arg1)->ts);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_TryGetValueResult() {
  void * jresult ;
  RobotRaconteur::TryGetValueResult *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::TryGetValueResult *)new RobotRaconteur::TryGetValueResult();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_TryGetValueResult(void * jarg1) {
  RobotRaconteur::TryGetValueResult *arg1 = (RobotRaconteur::TryGetValueResult *) 0 ;
  
  arg1 = (RobotRaconteur::TryGetValueResult *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireConnection_GetInValue(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedWireConnection *arg1 = (RobotRaconteur::WrappedWireConnection *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireConnection > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireConnection *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetInValue();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireConnection_GetOutValue(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedWireConnection *arg1 = (RobotRaconteur::WrappedWireConnection *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireConnection > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireConnection *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetOutValue();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireConnection_SetOutValue(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedWireConnection *arg1 = (RobotRaconteur::WrappedWireConnection *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > temp2 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireConnection > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireConnection *)(smartarg1 ? smartarg1->get() : 0); 
  
  // intrusive_ptr by reference
  if ( jarg2 ) {
    smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg2;
    temp2 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg2->get(), true);
    arg2 = &temp2;
  } else {
    arg2 = &tempnull2;
  }
  
  
  try {
    (arg1)->SetOutValue((boost::intrusive_ptr< RobotRaconteur::MessageElement > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireConnection_SetRRDirector(void * jarg1, void * jarg2, int jarg3) {
  RobotRaconteur::WrappedWireConnection *arg1 = (RobotRaconteur::WrappedWireConnection *) 0 ;
  RobotRaconteur::WrappedWireConnectionDirector *arg2 = (RobotRaconteur::WrappedWireConnectionDirector *) 0 ;
  int32_t arg3 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireConnection > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireConnection *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::WrappedWireConnectionDirector *)jarg2; 
  arg3 = (int32_t)jarg3; 
  
  try {
    (arg1)->SetRRDirector(arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireConnection_Type_set(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedWireConnection *arg1 = (RobotRaconteur::WrappedWireConnection *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireConnection > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireConnection *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::TypeDefinition > *)jarg2 : &tempnull2; 
  if (arg1) (arg1)->Type = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireConnection_Type_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedWireConnection *arg1 = (RobotRaconteur::WrappedWireConnection *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireConnection > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireConnection *)(smartarg1 ? smartarg1->get() : 0); 
  result = (boost::shared_ptr< RobotRaconteur::TypeDefinition > *) & ((arg1)->Type);
  jresult = *result ? new boost::shared_ptr< RobotRaconteur::TypeDefinition >(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireConnection_Close(void * jarg1) {
  RobotRaconteur::WrappedWireConnection *arg1 = (RobotRaconteur::WrappedWireConnection *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireConnection > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireConnection *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->Close();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireConnection_GetEndpoint(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::WrappedWireConnection *arg1 = (RobotRaconteur::WrappedWireConnection *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *smartarg1 = 0 ;
  uint32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireConnection > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireConnection *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (uint32_t)(arg1)->GetEndpoint();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireConnection_GetLastValueReceivedTime(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedWireConnection *arg1 = (RobotRaconteur::WrappedWireConnection *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *smartarg1 = 0 ;
  RobotRaconteur::TimeSpec result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireConnection > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireConnection *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetLastValueReceivedTime();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::TimeSpec((const RobotRaconteur::TimeSpec &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireConnection_GetLastValueSentTime(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedWireConnection *arg1 = (RobotRaconteur::WrappedWireConnection *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *smartarg1 = 0 ;
  RobotRaconteur::TimeSpec result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireConnection > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireConnection *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetLastValueSentTime();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::TimeSpec((const RobotRaconteur::TimeSpec &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireConnection_GetInValueValid(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::WrappedWireConnection *arg1 = (RobotRaconteur::WrappedWireConnection *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireConnection > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireConnection *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->GetInValueValid();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireConnection_GetOutValueValid(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::WrappedWireConnection *arg1 = (RobotRaconteur::WrappedWireConnection *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireConnection > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireConnection *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->GetOutValueValid();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireConnection_TryGetInValue(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedWireConnection *arg1 = (RobotRaconteur::WrappedWireConnection *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *smartarg1 = 0 ;
  RobotRaconteur::TryGetValueResult result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireConnection > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireConnection *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->TryGetInValue();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::TryGetValueResult((const RobotRaconteur::TryGetValueResult &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireConnection_TryGetOutValue(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedWireConnection *arg1 = (RobotRaconteur::WrappedWireConnection *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *smartarg1 = 0 ;
  RobotRaconteur::TryGetValueResult result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireConnection > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireConnection *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->TryGetOutValue();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::TryGetValueResult((const RobotRaconteur::TryGetValueResult &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireConnection_AsyncClose(void * jarg1, int jarg2, void * jarg3, int jarg4) {
  RobotRaconteur::WrappedWireConnection *arg1 = (RobotRaconteur::WrappedWireConnection *) 0 ;
  int32_t arg2 ;
  RobotRaconteur::AsyncVoidReturnDirector *arg3 = (RobotRaconteur::AsyncVoidReturnDirector *) 0 ;
  int32_t arg4 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireConnection > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireConnection *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  arg3 = (RobotRaconteur::AsyncVoidReturnDirector *)jarg3; 
  arg4 = (int32_t)jarg4; 
  
  try {
    (arg1)->AsyncClose(arg2,arg3,arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireConnection_GetNode(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedWireConnection *arg1 = (RobotRaconteur::WrappedWireConnection *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireConnection > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireConnection *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetNode();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::RobotRaconteurNode >(result) : 0; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireConnection_GetIgnoreInValue(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::WrappedWireConnection *arg1 = (RobotRaconteur::WrappedWireConnection *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireConnection > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireConnection *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->GetIgnoreInValue();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireConnection_SetIgnoreInValue(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::WrappedWireConnection *arg1 = (RobotRaconteur::WrappedWireConnection *) 0 ;
  bool arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireConnection > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireConnection *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? true : false; 
  
  try {
    (arg1)->SetIgnoreInValue(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireConnection_GetInValueLifespan(void * jarg1) {
  int jresult ;
  RobotRaconteur::WrappedWireConnection *arg1 = (RobotRaconteur::WrappedWireConnection *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *smartarg1 = 0 ;
  int32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireConnection > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireConnection *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (int32_t)(arg1)->GetInValueLifespan();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireConnection_SetInValueLifespan(void * jarg1, int jarg2) {
  RobotRaconteur::WrappedWireConnection *arg1 = (RobotRaconteur::WrappedWireConnection *) 0 ;
  int32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireConnection > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireConnection *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  
  try {
    (arg1)->SetInValueLifespan(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireConnection_GetOutValueLifespan(void * jarg1) {
  int jresult ;
  RobotRaconteur::WrappedWireConnection *arg1 = (RobotRaconteur::WrappedWireConnection *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *smartarg1 = 0 ;
  int32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireConnection > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireConnection *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (int32_t)(arg1)->GetOutValueLifespan();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireConnection_SetOutValueLifespan(void * jarg1, int jarg2) {
  RobotRaconteur::WrappedWireConnection *arg1 = (RobotRaconteur::WrappedWireConnection *) 0 ;
  int32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireConnection > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireConnection *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  
  try {
    (arg1)->SetOutValueLifespan(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireConnection_WaitInValueValid__SWIG_0(void * jarg1, int jarg2) {
  unsigned int jresult ;
  RobotRaconteur::WrappedWireConnection *arg1 = (RobotRaconteur::WrappedWireConnection *) 0 ;
  int32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireConnection > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireConnection *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  
  try {
    result = (bool)(arg1)->WaitInValueValid(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireConnection_WaitInValueValid__SWIG_1(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::WrappedWireConnection *arg1 = (RobotRaconteur::WrappedWireConnection *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireConnection > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireConnection *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->WaitInValueValid();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireConnection_WaitOutValueValid__SWIG_0(void * jarg1, int jarg2) {
  unsigned int jresult ;
  RobotRaconteur::WrappedWireConnection *arg1 = (RobotRaconteur::WrappedWireConnection *) 0 ;
  int32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireConnection > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireConnection *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  
  try {
    result = (bool)(arg1)->WaitOutValueValid(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireConnection_WaitOutValueValid__SWIG_1(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::WrappedWireConnection *arg1 = (RobotRaconteur::WrappedWireConnection *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireConnection > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireConnection *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->WaitOutValueValid();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireConnection_Direction(void * jarg1) {
  int jresult ;
  RobotRaconteur::WrappedWireConnection *arg1 = (RobotRaconteur::WrappedWireConnection *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *smartarg1 = 0 ;
  RobotRaconteur::MemberDefinition_Direction result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireConnection > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireConnection *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (RobotRaconteur::MemberDefinition_Direction)(arg1)->Direction();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedWireConnection(void * jarg1) {
  RobotRaconteur::WrappedWireConnection *arg1 = (RobotRaconteur::WrappedWireConnection *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireConnection > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireConnection *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireClient_Connect(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedWireClient *arg1 = (RobotRaconteur::WrappedWireClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireClient > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->Connect();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedWireConnection >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireClient_AsyncConnect(void * jarg1, int jarg2, void * jarg3, int jarg4) {
  RobotRaconteur::WrappedWireClient *arg1 = (RobotRaconteur::WrappedWireClient *) 0 ;
  int32_t arg2 ;
  RobotRaconteur::AsyncWireConnectionReturnDirector *arg3 = (RobotRaconteur::AsyncWireConnectionReturnDirector *) 0 ;
  int32_t arg4 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireClient > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireClient *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  arg3 = (RobotRaconteur::AsyncWireConnectionReturnDirector *)jarg3; 
  arg4 = (int32_t)jarg4; 
  
  try {
    (arg1)->AsyncConnect(arg2,arg3,arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireClient_GetMemberName(void * jarg1) {
  char * jresult ;
  RobotRaconteur::WrappedWireClient *arg1 = (RobotRaconteur::WrappedWireClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireClient > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetMemberName();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireClient_PeekInValue(void * jarg1, void * jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedWireClient *arg1 = (RobotRaconteur::WrappedWireClient *) 0 ;
  RobotRaconteur::TimeSpec *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireClient > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireClient *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::TimeSpec *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::TimeSpec & type is null", 0);
    return 0;
  } 
  
  try {
    result = (arg1)->PeekInValue(*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireClient_PeekOutValue(void * jarg1, void * jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedWireClient *arg1 = (RobotRaconteur::WrappedWireClient *) 0 ;
  RobotRaconteur::TimeSpec *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireClient > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireClient *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::TimeSpec *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::TimeSpec & type is null", 0);
    return 0;
  } 
  
  try {
    result = (arg1)->PeekOutValue(*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireClient_PokeOutValue(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedWireClient *arg1 = (RobotRaconteur::WrappedWireClient *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireClient > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > temp2 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  // intrusive_ptr by reference
  if ( jarg2 ) {
    smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg2;
    temp2 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg2->get(), true);
    arg2 = &temp2;
  } else {
    arg2 = &tempnull2;
  }
  
  
  try {
    (arg1)->PokeOutValue((boost::intrusive_ptr< RobotRaconteur::MessageElement > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireClient_AsyncPeekInValue(void * jarg1, int jarg2, void * jarg3, int jarg4) {
  RobotRaconteur::WrappedWireClient *arg1 = (RobotRaconteur::WrappedWireClient *) 0 ;
  int32_t arg2 ;
  RobotRaconteur::AsyncWirePeekReturnDirector *arg3 = (RobotRaconteur::AsyncWirePeekReturnDirector *) 0 ;
  int32_t arg4 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireClient > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireClient *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  arg3 = (RobotRaconteur::AsyncWirePeekReturnDirector *)jarg3; 
  arg4 = (int32_t)jarg4; 
  
  try {
    (arg1)->AsyncPeekInValue(arg2,arg3,arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireClient_AsyncPeekOutValue(void * jarg1, int jarg2, void * jarg3, int jarg4) {
  RobotRaconteur::WrappedWireClient *arg1 = (RobotRaconteur::WrappedWireClient *) 0 ;
  int32_t arg2 ;
  RobotRaconteur::AsyncWirePeekReturnDirector *arg3 = (RobotRaconteur::AsyncWirePeekReturnDirector *) 0 ;
  int32_t arg4 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireClient > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireClient *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  arg3 = (RobotRaconteur::AsyncWirePeekReturnDirector *)jarg3; 
  arg4 = (int32_t)jarg4; 
  
  try {
    (arg1)->AsyncPeekOutValue(arg2,arg3,arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireClient_AsyncPokeOutValue(void * jarg1, void * jarg2, int jarg3, void * jarg4, int jarg5) {
  RobotRaconteur::WrappedWireClient *arg1 = (RobotRaconteur::WrappedWireClient *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *arg2 = 0 ;
  int32_t arg3 ;
  RobotRaconteur::AsyncVoidReturnDirector *arg4 = (RobotRaconteur::AsyncVoidReturnDirector *) 0 ;
  int32_t arg5 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireClient > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > temp2 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  // intrusive_ptr by reference
  if ( jarg2 ) {
    smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg2;
    temp2 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg2->get(), true);
    arg2 = &temp2;
  } else {
    arg2 = &tempnull2;
  }
  
  arg3 = (int32_t)jarg3; 
  arg4 = (RobotRaconteur::AsyncVoidReturnDirector *)jarg4; 
  arg5 = (int32_t)jarg5; 
  
  try {
    (arg1)->AsyncPokeOutValue((boost::intrusive_ptr< RobotRaconteur::MessageElement > const &)*arg2,arg3,arg4,arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireClient_Type_set(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedWireClient *arg1 = (RobotRaconteur::WrappedWireClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireClient > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireClient *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::TypeDefinition > *)jarg2 : &tempnull2; 
  if (arg1) (arg1)->Type = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireClient_Type_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedWireClient *arg1 = (RobotRaconteur::WrappedWireClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireClient > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireClient *)(smartarg1 ? smartarg1->get() : 0); 
  result = (boost::shared_ptr< RobotRaconteur::TypeDefinition > *) & ((arg1)->Type);
  jresult = *result ? new boost::shared_ptr< RobotRaconteur::TypeDefinition >(*result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireClient_GetNode(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedWireClient *arg1 = (RobotRaconteur::WrappedWireClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireClient > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetNode();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::RobotRaconteurNode >(result) : 0; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireClient_Direction(void * jarg1) {
  int jresult ;
  RobotRaconteur::WrappedWireClient *arg1 = (RobotRaconteur::WrappedWireClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireClient > *smartarg1 = 0 ;
  RobotRaconteur::MemberDefinition_Direction result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (RobotRaconteur::MemberDefinition_Direction)(arg1)->Direction();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedWireClient(void * jarg1) {
  RobotRaconteur::WrappedWireClient *arg1 = (RobotRaconteur::WrappedWireClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireClient > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedWireServerConnectDirector(void * jarg1) {
  RobotRaconteur::WrappedWireServerConnectDirector *arg1 = (RobotRaconteur::WrappedWireServerConnectDirector *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedWireServerConnectDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireServerConnectDirector_WireConnectCallback(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedWireServerConnectDirector *arg1 = (RobotRaconteur::WrappedWireServerConnectDirector *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > tempnull2 ;
  
  arg1 = (RobotRaconteur::WrappedWireServerConnectDirector *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedWireConnection > *)jarg2 : &tempnull2; 
  
  try {
    (arg1)->WireConnectCallback((boost::shared_ptr< RobotRaconteur::WrappedWireConnection > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedWireServerConnectDirector() {
  void * jresult ;
  RobotRaconteur::WrappedWireServerConnectDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedWireServerConnectDirector *)new SwigDirector_WrappedWireServerConnectDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireServerConnectDirector_director_connect(void *objarg, SwigDirector_WrappedWireServerConnectDirector::SWIG_Callback0_t callback0) {
  RobotRaconteur::WrappedWireServerConnectDirector *obj = (RobotRaconteur::WrappedWireServerConnectDirector *)objarg;
  SwigDirector_WrappedWireServerConnectDirector *director = static_cast<SwigDirector_WrappedWireServerConnectDirector *>(obj);
  director->swig_connect_director(callback0);
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedWireServerPeekValueDirector(void * jarg1) {
  RobotRaconteur::WrappedWireServerPeekValueDirector *arg1 = (RobotRaconteur::WrappedWireServerPeekValueDirector *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedWireServerPeekValueDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireServerPeekValueDirector_PeekValue(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedWireServerPeekValueDirector *arg1 = (RobotRaconteur::WrappedWireServerPeekValueDirector *) 0 ;
  uint32_t *arg2 = 0 ;
  uint32_t temp2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > result;
  
  arg1 = (RobotRaconteur::WrappedWireServerPeekValueDirector *)jarg1; 
  temp2 = (uint32_t)jarg2; 
  arg2 = &temp2; 
  
  try {
    result = (arg1)->PeekValue((uint32_t const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedWireServerPeekValueDirector() {
  void * jresult ;
  RobotRaconteur::WrappedWireServerPeekValueDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedWireServerPeekValueDirector *)new SwigDirector_WrappedWireServerPeekValueDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireServerPeekValueDirector_director_connect(void *objarg, SwigDirector_WrappedWireServerPeekValueDirector::SWIG_Callback0_t callback0) {
  RobotRaconteur::WrappedWireServerPeekValueDirector *obj = (RobotRaconteur::WrappedWireServerPeekValueDirector *)objarg;
  SwigDirector_WrappedWireServerPeekValueDirector *director = static_cast<SwigDirector_WrappedWireServerPeekValueDirector *>(obj);
  director->swig_connect_director(callback0);
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedWireServerPokeValueDirector(void * jarg1) {
  RobotRaconteur::WrappedWireServerPokeValueDirector *arg1 = (RobotRaconteur::WrappedWireServerPokeValueDirector *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedWireServerPokeValueDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireServerPokeValueDirector_PokeValue(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
  RobotRaconteur::WrappedWireServerPokeValueDirector *arg1 = (RobotRaconteur::WrappedWireServerPokeValueDirector *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > arg2 ;
  RobotRaconteur::TimeSpec *arg3 = 0 ;
  uint32_t *arg4 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg2 ;
  uint32_t temp4 ;
  
  arg1 = (RobotRaconteur::WrappedWireServerPokeValueDirector *)jarg1; 
  
  // intrusive_ptr by value
  smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg2;
  if (smartarg2) {
    arg2 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg2->get(), true);
  }
  
  arg3 = (RobotRaconteur::TimeSpec *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::TimeSpec const & type is null", 0);
    return ;
  } 
  temp4 = (uint32_t)jarg4; 
  arg4 = &temp4; 
  
  try {
    (arg1)->PokeValue(arg2,(RobotRaconteur::TimeSpec const &)*arg3,(uint32_t const &)*arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedWireServerPokeValueDirector() {
  void * jresult ;
  RobotRaconteur::WrappedWireServerPokeValueDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedWireServerPokeValueDirector *)new SwigDirector_WrappedWireServerPokeValueDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireServerPokeValueDirector_director_connect(void *objarg, SwigDirector_WrappedWireServerPokeValueDirector::SWIG_Callback0_t callback0) {
  RobotRaconteur::WrappedWireServerPokeValueDirector *obj = (RobotRaconteur::WrappedWireServerPokeValueDirector *)objarg;
  SwigDirector_WrappedWireServerPokeValueDirector *director = static_cast<SwigDirector_WrappedWireServerPokeValueDirector *>(obj);
  director->swig_connect_director(callback0);
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireServer_GetMemberName(void * jarg1) {
  char * jresult ;
  RobotRaconteur::WrappedWireServer *arg1 = (RobotRaconteur::WrappedWireServer *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireServer > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireServer > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireServer *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetMemberName();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireServer_Type_set(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedWireServer *arg1 = (RobotRaconteur::WrappedWireServer *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireServer > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireServer > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireServer *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::TypeDefinition > *)jarg2 : &tempnull2; 
  if (arg1) (arg1)->Type = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireServer_Type_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedWireServer *arg1 = (RobotRaconteur::WrappedWireServer *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireServer > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireServer > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireServer *)(smartarg1 ? smartarg1->get() : 0); 
  result = (boost::shared_ptr< RobotRaconteur::TypeDefinition > *) & ((arg1)->Type);
  jresult = *result ? new boost::shared_ptr< RobotRaconteur::TypeDefinition >(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireServer_SetWrappedWireConnectCallback(void * jarg1, void * jarg2, int jarg3) {
  RobotRaconteur::WrappedWireServer *arg1 = (RobotRaconteur::WrappedWireServer *) 0 ;
  RobotRaconteur::WrappedWireServerConnectDirector *arg2 = (RobotRaconteur::WrappedWireServerConnectDirector *) 0 ;
  int32_t arg3 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireServer > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireServer > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireServer *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::WrappedWireServerConnectDirector *)jarg2; 
  arg3 = (int32_t)jarg3; 
  
  try {
    (arg1)->SetWrappedWireConnectCallback(arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireServer_GetNode(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedWireServer *arg1 = (RobotRaconteur::WrappedWireServer *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireServer > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireServer > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireServer *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetNode();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::RobotRaconteurNode >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireServer_SetPeekInValueCallback(void * jarg1, void * jarg2, int jarg3) {
  RobotRaconteur::WrappedWireServer *arg1 = (RobotRaconteur::WrappedWireServer *) 0 ;
  RobotRaconteur::WrappedWireServerPeekValueDirector *arg2 = (RobotRaconteur::WrappedWireServerPeekValueDirector *) 0 ;
  int32_t arg3 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireServer > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireServer > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireServer *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::WrappedWireServerPeekValueDirector *)jarg2; 
  arg3 = (int32_t)jarg3; 
  
  try {
    (arg1)->SetPeekInValueCallback(arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireServer_SetPeekOutValueCallback(void * jarg1, void * jarg2, int jarg3) {
  RobotRaconteur::WrappedWireServer *arg1 = (RobotRaconteur::WrappedWireServer *) 0 ;
  RobotRaconteur::WrappedWireServerPeekValueDirector *arg2 = (RobotRaconteur::WrappedWireServerPeekValueDirector *) 0 ;
  int32_t arg3 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireServer > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireServer > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireServer *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::WrappedWireServerPeekValueDirector *)jarg2; 
  arg3 = (int32_t)jarg3; 
  
  try {
    (arg1)->SetPeekOutValueCallback(arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireServer_SetPokeOutValueCallback(void * jarg1, void * jarg2, int jarg3) {
  RobotRaconteur::WrappedWireServer *arg1 = (RobotRaconteur::WrappedWireServer *) 0 ;
  RobotRaconteur::WrappedWireServerPokeValueDirector *arg2 = (RobotRaconteur::WrappedWireServerPokeValueDirector *) 0 ;
  int32_t arg3 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireServer > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireServer > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireServer *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::WrappedWireServerPokeValueDirector *)jarg2; 
  arg3 = (int32_t)jarg3; 
  
  try {
    (arg1)->SetPokeOutValueCallback(arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireServer_Direction(void * jarg1) {
  int jresult ;
  RobotRaconteur::WrappedWireServer *arg1 = (RobotRaconteur::WrappedWireServer *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireServer > *smartarg1 = 0 ;
  RobotRaconteur::MemberDefinition_Direction result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireServer > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireServer *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (RobotRaconteur::MemberDefinition_Direction)(arg1)->Direction();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedWireServer(void * jarg1) {
  RobotRaconteur::WrappedWireServer *arg1 = (RobotRaconteur::WrappedWireServer *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireServer > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireServer > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireServer *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireBroadcasterPredicateDirector_Predicate(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ;
  RobotRaconteur::WrappedWireBroadcasterPredicateDirector *arg1 = (RobotRaconteur::WrappedWireBroadcasterPredicateDirector *) 0 ;
  uint32_t arg2 ;
  bool result;
  
  arg1 = (RobotRaconteur::WrappedWireBroadcasterPredicateDirector *)jarg1; 
  arg2 = (uint32_t)jarg2; 
  
  try {
    result = (bool)(arg1)->Predicate(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedWireBroadcasterPredicateDirector(void * jarg1) {
  RobotRaconteur::WrappedWireBroadcasterPredicateDirector *arg1 = (RobotRaconteur::WrappedWireBroadcasterPredicateDirector *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedWireBroadcasterPredicateDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedWireBroadcasterPredicateDirector() {
  void * jresult ;
  RobotRaconteur::WrappedWireBroadcasterPredicateDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedWireBroadcasterPredicateDirector *)new SwigDirector_WrappedWireBroadcasterPredicateDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireBroadcasterPredicateDirector_director_connect(void *objarg, SwigDirector_WrappedWireBroadcasterPredicateDirector::SWIG_Callback0_t callback0) {
  RobotRaconteur::WrappedWireBroadcasterPredicateDirector *obj = (RobotRaconteur::WrappedWireBroadcasterPredicateDirector *)objarg;
  SwigDirector_WrappedWireBroadcasterPredicateDirector *director = static_cast<SwigDirector_WrappedWireBroadcasterPredicateDirector *>(obj);
  director->swig_connect_director(callback0);
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireBroadcaster_Init(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedWireBroadcaster *arg1 = (RobotRaconteur::WrappedWireBroadcaster *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireServer > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireBroadcaster > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireServer > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireBroadcaster > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireBroadcaster *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedWireServer > *)jarg2 : &tempnull2; 
  
  try {
    (arg1)->Init((boost::shared_ptr< RobotRaconteur::WrappedWireServer > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireBroadcaster_SetOutValue(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedWireBroadcaster *arg1 = (RobotRaconteur::WrappedWireBroadcaster *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireBroadcaster > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > temp2 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireBroadcaster > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireBroadcaster *)(smartarg1 ? smartarg1->get() : 0); 
  
  // intrusive_ptr by reference
  if ( jarg2 ) {
    smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg2;
    temp2 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg2->get(), true);
    arg2 = &temp2;
  } else {
    arg2 = &tempnull2;
  }
  
  
  try {
    (arg1)->SetOutValue((boost::intrusive_ptr< RobotRaconteur::MessageElement > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireBroadcaster_GetActiveWireConnectionCount(void * jarg1) {
  unsigned long jresult ;
  RobotRaconteur::WrappedWireBroadcaster *arg1 = (RobotRaconteur::WrappedWireBroadcaster *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireBroadcaster > *smartarg1 = 0 ;
  size_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireBroadcaster > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireBroadcaster *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetActiveWireConnectionCount();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireBroadcaster_SetPredicateDirector(void * jarg1, void * jarg2, int jarg3) {
  RobotRaconteur::WrappedWireBroadcaster *arg1 = (RobotRaconteur::WrappedWireBroadcaster *) 0 ;
  RobotRaconteur::WrappedWireBroadcasterPredicateDirector *arg2 = (RobotRaconteur::WrappedWireBroadcasterPredicateDirector *) 0 ;
  int32_t arg3 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireBroadcaster > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireBroadcaster > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireBroadcaster *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::WrappedWireBroadcasterPredicateDirector *)jarg2; 
  arg3 = (int32_t)jarg3; 
  
  try {
    (arg1)->SetPredicateDirector(arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireBroadcaster_GetOutValueLifespan(void * jarg1) {
  int jresult ;
  RobotRaconteur::WrappedWireBroadcaster *arg1 = (RobotRaconteur::WrappedWireBroadcaster *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireBroadcaster > *smartarg1 = 0 ;
  int32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireBroadcaster > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireBroadcaster *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (int32_t)(arg1)->GetOutValueLifespan();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireBroadcaster_SetOutValueLifespan(void * jarg1, int jarg2) {
  RobotRaconteur::WrappedWireBroadcaster *arg1 = (RobotRaconteur::WrappedWireBroadcaster *) 0 ;
  int32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireBroadcaster > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireBroadcaster > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireBroadcaster *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  
  try {
    (arg1)->SetOutValueLifespan(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireBroadcaster_SetPeekInValueCallback(void * jarg1, void * jarg2, int jarg3) {
  RobotRaconteur::WrappedWireBroadcaster *arg1 = (RobotRaconteur::WrappedWireBroadcaster *) 0 ;
  RobotRaconteur::WrappedWireServerPeekValueDirector *arg2 = (RobotRaconteur::WrappedWireServerPeekValueDirector *) 0 ;
  int32_t arg3 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireBroadcaster > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireBroadcaster > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireBroadcaster *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::WrappedWireServerPeekValueDirector *)jarg2; 
  arg3 = (int32_t)jarg3; 
  
  try {
    (arg1)->SetPeekInValueCallback(arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedWireBroadcaster() {
  void * jresult ;
  RobotRaconteur::WrappedWireBroadcaster *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedWireBroadcaster *)new RobotRaconteur::WrappedWireBroadcaster();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::WrappedWireBroadcaster >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedWireBroadcaster(void * jarg1) {
  RobotRaconteur::WrappedWireBroadcaster *arg1 = (RobotRaconteur::WrappedWireBroadcaster *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireBroadcaster > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireBroadcaster > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireBroadcaster *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireUnicastReceiver_Init(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedWireUnicastReceiver *arg1 = (RobotRaconteur::WrappedWireUnicastReceiver *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireServer > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireUnicastReceiver > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireServer > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireUnicastReceiver > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireUnicastReceiver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedWireServer > *)jarg2 : &tempnull2; 
  
  try {
    (arg1)->Init((boost::shared_ptr< RobotRaconteur::WrappedWireServer > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireUnicastReceiver_GetInValue(void * jarg1, void * jarg2, unsigned int * jarg3) {
  void * jresult ;
  RobotRaconteur::WrappedWireUnicastReceiver *arg1 = (RobotRaconteur::WrappedWireUnicastReceiver *) 0 ;
  RobotRaconteur::TimeSpec *arg2 = 0 ;
  uint32_t *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireUnicastReceiver > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireUnicastReceiver > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireUnicastReceiver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::TimeSpec *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::TimeSpec & type is null", 0);
    return 0;
  } 
  arg3 = (uint32_t *)jarg3; 
  
  try {
    result = (arg1)->GetInValue(*arg2,*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireUnicastReceiver_AddInValueChangedListener(void * jarg1, void * jarg2, int jarg3) {
  RobotRaconteur::WrappedWireUnicastReceiver *arg1 = (RobotRaconteur::WrappedWireUnicastReceiver *) 0 ;
  RobotRaconteur::WrappedWireServerPokeValueDirector *arg2 = (RobotRaconteur::WrappedWireServerPokeValueDirector *) 0 ;
  int32_t arg3 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireUnicastReceiver > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireUnicastReceiver > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireUnicastReceiver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::WrappedWireServerPokeValueDirector *)jarg2; 
  arg3 = (int32_t)jarg3; 
  
  try {
    (arg1)->AddInValueChangedListener(arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireUnicastReceiver_GetInValueLifespan(void * jarg1) {
  int jresult ;
  RobotRaconteur::WrappedWireUnicastReceiver *arg1 = (RobotRaconteur::WrappedWireUnicastReceiver *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireUnicastReceiver > *smartarg1 = 0 ;
  int32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireUnicastReceiver > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireUnicastReceiver *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (int32_t)(arg1)->GetInValueLifespan();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireUnicastReceiver_SetInValueLifespan(void * jarg1, int jarg2) {
  RobotRaconteur::WrappedWireUnicastReceiver *arg1 = (RobotRaconteur::WrappedWireUnicastReceiver *) 0 ;
  int32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireUnicastReceiver > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireUnicastReceiver > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireUnicastReceiver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  
  try {
    (arg1)->SetInValueLifespan(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireUnicastReceiver_TryGetInValue(void * jarg1, void * jarg2, void * jarg3) {
  unsigned int jresult ;
  RobotRaconteur::WrappedWireUnicastReceiver *arg1 = (RobotRaconteur::WrappedWireUnicastReceiver *) 0 ;
  RobotRaconteur::WrappedService_typed_packet *arg2 = 0 ;
  RobotRaconteur::TimeSpec *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireUnicastReceiver > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireUnicastReceiver > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireUnicastReceiver *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::WrappedService_typed_packet *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::WrappedService_typed_packet & type is null", 0);
    return 0;
  } 
  arg3 = (RobotRaconteur::TimeSpec *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::TimeSpec & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)(arg1)->TryGetInValue(*arg2,*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedWireUnicastReceiver() {
  void * jresult ;
  RobotRaconteur::WrappedWireUnicastReceiver *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedWireUnicastReceiver *)new RobotRaconteur::WrappedWireUnicastReceiver();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::WrappedWireUnicastReceiver >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedWireUnicastReceiver(void * jarg1) {
  RobotRaconteur::WrappedWireUnicastReceiver *arg1 = (RobotRaconteur::WrappedWireUnicastReceiver *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireUnicastReceiver > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireUnicastReceiver > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireUnicastReceiver *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long long SWIGSTDCALL CSharp_RobotRaconteur_ArrayMemoryBase_Length(void * jarg1) {
  unsigned long long jresult ;
  RobotRaconteur::ArrayMemoryBase *arg1 = (RobotRaconteur::ArrayMemoryBase *) 0 ;
  boost::shared_ptr< RobotRaconteur::ArrayMemoryBase > *smartarg1 = 0 ;
  uint64_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ArrayMemoryBase > *)jarg1;
  arg1 = (RobotRaconteur::ArrayMemoryBase *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (uint64_t)(arg1)->Length();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_ArrayMemoryBase_ElementTypeID(void * jarg1) {
  int jresult ;
  RobotRaconteur::ArrayMemoryBase *arg1 = (RobotRaconteur::ArrayMemoryBase *) 0 ;
  boost::shared_ptr< RobotRaconteur::ArrayMemoryBase > *smartarg1 = 0 ;
  RobotRaconteur::DataTypes result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ArrayMemoryBase > *)jarg1;
  arg1 = (RobotRaconteur::ArrayMemoryBase *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (RobotRaconteur::DataTypes)(arg1)->ElementTypeID();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_ArrayMemoryBase(void * jarg1) {
  RobotRaconteur::ArrayMemoryBase *arg1 = (RobotRaconteur::ArrayMemoryBase *) 0 ;
  boost::shared_ptr< RobotRaconteur::ArrayMemoryBase > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ArrayMemoryBase > *)jarg1;
  arg1 = (RobotRaconteur::ArrayMemoryBase *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_MultiDimArrayMemoryBase_Dimensions(void * jarg1) {
  void * jresult ;
  RobotRaconteur::MultiDimArrayMemoryBase *arg1 = (RobotRaconteur::MultiDimArrayMemoryBase *) 0 ;
  boost::shared_ptr< RobotRaconteur::MultiDimArrayMemoryBase > *smartarg1 = 0 ;
  std::vector< uint64_t > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::MultiDimArrayMemoryBase > *)jarg1;
  arg1 = (RobotRaconteur::MultiDimArrayMemoryBase *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->Dimensions();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< uint64_t >((const std::vector< uint64_t > &)result); 
  return jresult;
}


SWIGEXPORT unsigned long long SWIGSTDCALL CSharp_RobotRaconteur_MultiDimArrayMemoryBase_DimCount(void * jarg1) {
  unsigned long long jresult ;
  RobotRaconteur::MultiDimArrayMemoryBase *arg1 = (RobotRaconteur::MultiDimArrayMemoryBase *) 0 ;
  boost::shared_ptr< RobotRaconteur::MultiDimArrayMemoryBase > *smartarg1 = 0 ;
  uint64_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::MultiDimArrayMemoryBase > *)jarg1;
  arg1 = (RobotRaconteur::MultiDimArrayMemoryBase *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (uint64_t)(arg1)->DimCount();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_MultiDimArrayMemoryBase_ElementTypeID(void * jarg1) {
  int jresult ;
  RobotRaconteur::MultiDimArrayMemoryBase *arg1 = (RobotRaconteur::MultiDimArrayMemoryBase *) 0 ;
  boost::shared_ptr< RobotRaconteur::MultiDimArrayMemoryBase > *smartarg1 = 0 ;
  RobotRaconteur::DataTypes result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::MultiDimArrayMemoryBase > *)jarg1;
  arg1 = (RobotRaconteur::MultiDimArrayMemoryBase *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (RobotRaconteur::DataTypes)(arg1)->ElementTypeID();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_MultiDimArrayMemoryBase(void * jarg1) {
  RobotRaconteur::MultiDimArrayMemoryBase *arg1 = (RobotRaconteur::MultiDimArrayMemoryBase *) 0 ;
  boost::shared_ptr< RobotRaconteur::MultiDimArrayMemoryBase > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::MultiDimArrayMemoryBase > *)jarg1;
  arg1 = (RobotRaconteur::MultiDimArrayMemoryBase *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedArrayMemoryClientUtil_Read(void * jarg1, unsigned long long jarg2, unsigned long long jarg3) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::ArrayMemoryBase > *arg1 = 0 ;
  uint64_t arg2 ;
  uint64_t arg3 ;
  boost::shared_ptr< RobotRaconteur::ArrayMemoryBase > tempnull1 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > result;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::ArrayMemoryBase > *)jarg1 : &tempnull1; 
  arg2 = (uint64_t)jarg2; 
  arg3 = (uint64_t)jarg3; 
  
  try {
    result = RobotRaconteur::WrappedArrayMemoryClientUtil::Read((boost::shared_ptr< RobotRaconteur::ArrayMemoryBase > const &)*arg1,arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = new boost::shared_ptr<  RobotRaconteur::RRBaseArray >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::RRBaseArray >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::RRBaseArray > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedArrayMemoryClientUtil_Write(void * jarg1, unsigned long long jarg2, void * jarg3, unsigned long long jarg4, unsigned long long jarg5) {
  boost::shared_ptr< RobotRaconteur::ArrayMemoryBase > *arg1 = 0 ;
  uint64_t arg2 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > *arg3 = 0 ;
  uint64_t arg4 ;
  uint64_t arg5 ;
  boost::shared_ptr< RobotRaconteur::ArrayMemoryBase > tempnull1 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > tempnull3 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > temp3 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg3 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::ArrayMemoryBase > *)jarg1 : &tempnull1; 
  arg2 = (uint64_t)jarg2; 
  
  // intrusive_ptr by reference
  if ( jarg3 ) {
    smartarg3 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg3;
    temp3 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg3->get(), true);
    arg3 = &temp3;
  } else {
    arg3 = &tempnull3;
  }
  
  arg4 = (uint64_t)jarg4; 
  arg5 = (uint64_t)jarg5; 
  
  try {
    RobotRaconteur::WrappedArrayMemoryClientUtil::Write((boost::shared_ptr< RobotRaconteur::ArrayMemoryBase > const &)*arg1,arg2,(boost::intrusive_ptr< RobotRaconteur::RRBaseArray > const &)*arg3,arg4,arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WrappedArrayMemoryClientUtil_Direction(void * jarg1) {
  int jresult ;
  boost::shared_ptr< RobotRaconteur::ArrayMemoryBase > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ArrayMemoryBase > tempnull1 ;
  RobotRaconteur::MemberDefinition_Direction result;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::ArrayMemoryBase > *)jarg1 : &tempnull1; 
  
  try {
    result = (RobotRaconteur::MemberDefinition_Direction)RobotRaconteur::WrappedArrayMemoryClientUtil::Direction((boost::shared_ptr< RobotRaconteur::ArrayMemoryBase > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedArrayMemoryClientUtil() {
  void * jresult ;
  RobotRaconteur::WrappedArrayMemoryClientUtil *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedArrayMemoryClientUtil *)new RobotRaconteur::WrappedArrayMemoryClientUtil();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedArrayMemoryClientUtil(void * jarg1) {
  RobotRaconteur::WrappedArrayMemoryClientUtil *arg1 = (RobotRaconteur::WrappedArrayMemoryClientUtil *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedArrayMemoryClientUtil *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedMultiDimArrayMemoryClientUtil_Read(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::MultiDimArrayMemoryBase > *arg1 = 0 ;
  std::vector< uint64_t > arg2 ;
  std::vector< uint64_t > arg3 ;
  boost::shared_ptr< RobotRaconteur::MultiDimArrayMemoryBase > tempnull1 ;
  std::vector< uint64_t > *argp2 ;
  std::vector< uint64_t > *argp3 ;
  boost::shared_ptr< RobotRaconteur::RRMultiDimArrayUntyped > result;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::MultiDimArrayMemoryBase > *)jarg1 : &tempnull1; 
  argp2 = (std::vector< uint64_t > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< uint64_t >", 0);
    return 0;
  }
  arg2 = *argp2; 
  argp3 = (std::vector< uint64_t > *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< uint64_t >", 0);
    return 0;
  }
  arg3 = *argp3; 
  
  try {
    result = RobotRaconteur::WrappedMultiDimArrayMemoryClientUtil::Read((boost::shared_ptr< RobotRaconteur::MultiDimArrayMemoryBase > const &)*arg1,arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::RRMultiDimArrayUntyped >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedMultiDimArrayMemoryClientUtil_Write(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  boost::shared_ptr< RobotRaconteur::MultiDimArrayMemoryBase > *arg1 = 0 ;
  std::vector< uint64_t > arg2 ;
  boost::shared_ptr< RobotRaconteur::RRMultiDimArrayUntyped > *arg3 = 0 ;
  std::vector< uint64_t > arg4 ;
  std::vector< uint64_t > arg5 ;
  boost::shared_ptr< RobotRaconteur::MultiDimArrayMemoryBase > tempnull1 ;
  std::vector< uint64_t > *argp2 ;
  boost::shared_ptr< RobotRaconteur::RRMultiDimArrayUntyped > tempnull3 ;
  std::vector< uint64_t > *argp4 ;
  std::vector< uint64_t > *argp5 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::MultiDimArrayMemoryBase > *)jarg1 : &tempnull1; 
  argp2 = (std::vector< uint64_t > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< uint64_t >", 0);
    return ;
  }
  arg2 = *argp2; 
  arg3 = jarg3 ? (boost::shared_ptr< RobotRaconteur::RRMultiDimArrayUntyped > *)jarg3 : &tempnull3; 
  argp4 = (std::vector< uint64_t > *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< uint64_t >", 0);
    return ;
  }
  arg4 = *argp4; 
  argp5 = (std::vector< uint64_t > *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< uint64_t >", 0);
    return ;
  }
  arg5 = *argp5; 
  
  try {
    RobotRaconteur::WrappedMultiDimArrayMemoryClientUtil::Write((boost::shared_ptr< RobotRaconteur::MultiDimArrayMemoryBase > const &)*arg1,arg2,(boost::shared_ptr< RobotRaconteur::RRMultiDimArrayUntyped > const &)*arg3,arg4,arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WrappedMultiDimArrayMemoryClientUtil_Direction(void * jarg1) {
  int jresult ;
  boost::shared_ptr< RobotRaconteur::MultiDimArrayMemoryBase > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::MultiDimArrayMemoryBase > tempnull1 ;
  RobotRaconteur::MemberDefinition_Direction result;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::MultiDimArrayMemoryBase > *)jarg1 : &tempnull1; 
  
  try {
    result = (RobotRaconteur::MemberDefinition_Direction)RobotRaconteur::WrappedMultiDimArrayMemoryClientUtil::Direction((boost::shared_ptr< RobotRaconteur::MultiDimArrayMemoryBase > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedMultiDimArrayMemoryClientUtil() {
  void * jresult ;
  RobotRaconteur::WrappedMultiDimArrayMemoryClientUtil *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedMultiDimArrayMemoryClientUtil *)new RobotRaconteur::WrappedMultiDimArrayMemoryClientUtil();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedMultiDimArrayMemoryClientUtil(void * jarg1) {
  RobotRaconteur::WrappedMultiDimArrayMemoryClientUtil *arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryClientUtil *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryClientUtil *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPodArrayMemoryClientBuffer_UnpackReadResult(void * jarg1, void * jarg2, unsigned long long jarg3, unsigned long long jarg4) {
  RobotRaconteur::WrappedPodArrayMemoryClientBuffer *arg1 = (RobotRaconteur::WrappedPodArrayMemoryClientBuffer *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > arg2 ;
  uint64_t arg3 ;
  uint64_t arg4 ;
  boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > *smartarg2 ;
  
  arg1 = (RobotRaconteur::WrappedPodArrayMemoryClientBuffer *)jarg1; 
  
  // intrusive_ptr by value
  smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList >**)&jarg2;
  if (smartarg2) {
    arg2 = boost::intrusive_ptr<  RobotRaconteur::MessageElementNestedElementList >(smartarg2->get(), true);
  }
  
  arg3 = (uint64_t)jarg3; 
  arg4 = (uint64_t)jarg4; 
  
  try {
    (arg1)->UnpackReadResult(arg2,arg3,arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedPodArrayMemoryClientBuffer_PackWriteRequest(void * jarg1, unsigned long long jarg2, unsigned long long jarg3) {
  void * jresult ;
  RobotRaconteur::WrappedPodArrayMemoryClientBuffer *arg1 = (RobotRaconteur::WrappedPodArrayMemoryClientBuffer *) 0 ;
  uint64_t arg2 ;
  uint64_t arg3 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > result;
  
  arg1 = (RobotRaconteur::WrappedPodArrayMemoryClientBuffer *)jarg1; 
  arg2 = (uint64_t)jarg2; 
  arg3 = (uint64_t)jarg3; 
  
  try {
    result = (arg1)->PackWriteRequest(arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElementNestedElementList >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT unsigned long long SWIGSTDCALL CSharp_RobotRaconteur_WrappedPodArrayMemoryClientBuffer_GetBufferLength(void * jarg1) {
  unsigned long long jresult ;
  RobotRaconteur::WrappedPodArrayMemoryClientBuffer *arg1 = (RobotRaconteur::WrappedPodArrayMemoryClientBuffer *) 0 ;
  uint64_t result;
  
  arg1 = (RobotRaconteur::WrappedPodArrayMemoryClientBuffer *)jarg1; 
  
  try {
    result = (uint64_t)(arg1)->GetBufferLength();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedPodArrayMemoryClientBuffer(void * jarg1) {
  RobotRaconteur::WrappedPodArrayMemoryClientBuffer *arg1 = (RobotRaconteur::WrappedPodArrayMemoryClientBuffer *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedPodArrayMemoryClientBuffer *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedPodArrayMemoryClientBuffer() {
  void * jresult ;
  RobotRaconteur::WrappedPodArrayMemoryClientBuffer *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedPodArrayMemoryClientBuffer *)new SwigDirector_WrappedPodArrayMemoryClientBuffer();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPodArrayMemoryClientBuffer_director_connect(void *objarg, SwigDirector_WrappedPodArrayMemoryClientBuffer::SWIG_Callback0_t callback0, SwigDirector_WrappedPodArrayMemoryClientBuffer::SWIG_Callback1_t callback1, SwigDirector_WrappedPodArrayMemoryClientBuffer::SWIG_Callback2_t callback2) {
  RobotRaconteur::WrappedPodArrayMemoryClientBuffer *obj = (RobotRaconteur::WrappedPodArrayMemoryClientBuffer *)objarg;
  SwigDirector_WrappedPodArrayMemoryClientBuffer *director = static_cast<SwigDirector_WrappedPodArrayMemoryClientBuffer *>(obj);
  director->swig_connect_director(callback0, callback1, callback2);
}


SWIGEXPORT unsigned long long SWIGSTDCALL CSharp_RobotRaconteur_WrappedPodArrayMemoryClient_Length(void * jarg1) {
  unsigned long long jresult ;
  RobotRaconteur::WrappedPodArrayMemoryClient *arg1 = (RobotRaconteur::WrappedPodArrayMemoryClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPodArrayMemoryClient > *smartarg1 = 0 ;
  uint64_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPodArrayMemoryClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPodArrayMemoryClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (uint64_t)(arg1)->Length();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WrappedPodArrayMemoryClient_Direction(void * jarg1) {
  int jresult ;
  RobotRaconteur::WrappedPodArrayMemoryClient *arg1 = (RobotRaconteur::WrappedPodArrayMemoryClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPodArrayMemoryClient > *smartarg1 = 0 ;
  RobotRaconteur::MemberDefinition_Direction result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPodArrayMemoryClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPodArrayMemoryClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (RobotRaconteur::MemberDefinition_Direction)(arg1)->Direction();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPodArrayMemoryClient_Read(void * jarg1, unsigned long long jarg2, void * jarg3, unsigned long long jarg4, unsigned long long jarg5) {
  RobotRaconteur::WrappedPodArrayMemoryClient *arg1 = (RobotRaconteur::WrappedPodArrayMemoryClient *) 0 ;
  uint64_t arg2 ;
  RobotRaconteur::WrappedPodArrayMemoryClientBuffer *arg3 = (RobotRaconteur::WrappedPodArrayMemoryClientBuffer *) 0 ;
  uint64_t arg4 ;
  uint64_t arg5 ;
  boost::shared_ptr< RobotRaconteur::WrappedPodArrayMemoryClient > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPodArrayMemoryClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPodArrayMemoryClient *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (uint64_t)jarg2; 
  arg3 = (RobotRaconteur::WrappedPodArrayMemoryClientBuffer *)jarg3; 
  arg4 = (uint64_t)jarg4; 
  arg5 = (uint64_t)jarg5; 
  
  try {
    (arg1)->Read(arg2,arg3,arg4,arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPodArrayMemoryClient_Write(void * jarg1, unsigned long long jarg2, void * jarg3, unsigned long long jarg4, unsigned long long jarg5) {
  RobotRaconteur::WrappedPodArrayMemoryClient *arg1 = (RobotRaconteur::WrappedPodArrayMemoryClient *) 0 ;
  uint64_t arg2 ;
  RobotRaconteur::WrappedPodArrayMemoryClientBuffer *arg3 = (RobotRaconteur::WrappedPodArrayMemoryClientBuffer *) 0 ;
  uint64_t arg4 ;
  uint64_t arg5 ;
  boost::shared_ptr< RobotRaconteur::WrappedPodArrayMemoryClient > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPodArrayMemoryClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPodArrayMemoryClient *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (uint64_t)jarg2; 
  arg3 = (RobotRaconteur::WrappedPodArrayMemoryClientBuffer *)jarg3; 
  arg4 = (uint64_t)jarg4; 
  arg5 = (uint64_t)jarg5; 
  
  try {
    (arg1)->Write(arg2,arg3,arg4,arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedPodArrayMemoryClient(void * jarg1) {
  RobotRaconteur::WrappedPodArrayMemoryClient *arg1 = (RobotRaconteur::WrappedPodArrayMemoryClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPodArrayMemoryClient > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPodArrayMemoryClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPodArrayMemoryClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPodMultiDimArrayMemoryClientBuffer_UnpackReadResult(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  RobotRaconteur::WrappedPodMultiDimArrayMemoryClientBuffer *arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryClientBuffer *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > arg2 ;
  std::vector< uint64_t > *arg3 = 0 ;
  std::vector< uint64_t > *arg4 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > *smartarg2 ;
  
  arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryClientBuffer *)jarg1; 
  
  // intrusive_ptr by value
  smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList >**)&jarg2;
  if (smartarg2) {
    arg2 = boost::intrusive_ptr<  RobotRaconteur::MessageElementNestedElementList >(smartarg2->get(), true);
  }
  
  arg3 = (std::vector< uint64_t > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return ;
  } 
  arg4 = (std::vector< uint64_t > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->UnpackReadResult(arg2,(std::vector< uint64_t > const &)*arg3,(std::vector< uint64_t > const &)*arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedPodMultiDimArrayMemoryClientBuffer_PackWriteRequest(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  RobotRaconteur::WrappedPodMultiDimArrayMemoryClientBuffer *arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryClientBuffer *) 0 ;
  std::vector< uint64_t > *arg2 = 0 ;
  std::vector< uint64_t > *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > result;
  
  arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryClientBuffer *)jarg1; 
  arg2 = (std::vector< uint64_t > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< uint64_t > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (arg1)->PackWriteRequest((std::vector< uint64_t > const &)*arg2,(std::vector< uint64_t > const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElementNestedElementList >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedPodMultiDimArrayMemoryClientBuffer(void * jarg1) {
  RobotRaconteur::WrappedPodMultiDimArrayMemoryClientBuffer *arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryClientBuffer *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryClientBuffer *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedPodMultiDimArrayMemoryClientBuffer() {
  void * jresult ;
  RobotRaconteur::WrappedPodMultiDimArrayMemoryClientBuffer *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedPodMultiDimArrayMemoryClientBuffer *)new SwigDirector_WrappedPodMultiDimArrayMemoryClientBuffer();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPodMultiDimArrayMemoryClientBuffer_director_connect(void *objarg, SwigDirector_WrappedPodMultiDimArrayMemoryClientBuffer::SWIG_Callback0_t callback0, SwigDirector_WrappedPodMultiDimArrayMemoryClientBuffer::SWIG_Callback1_t callback1) {
  RobotRaconteur::WrappedPodMultiDimArrayMemoryClientBuffer *obj = (RobotRaconteur::WrappedPodMultiDimArrayMemoryClientBuffer *)objarg;
  SwigDirector_WrappedPodMultiDimArrayMemoryClientBuffer *director = static_cast<SwigDirector_WrappedPodMultiDimArrayMemoryClientBuffer *>(obj);
  director->swig_connect_director(callback0, callback1);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedPodMultiDimArrayMemoryClient_Dimensions(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedPodMultiDimArrayMemoryClient *arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPodMultiDimArrayMemoryClient > *smartarg1 = 0 ;
  std::vector< uint64_t > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPodMultiDimArrayMemoryClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->Dimensions();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< uint64_t >((const std::vector< uint64_t > &)result); 
  return jresult;
}


SWIGEXPORT unsigned long long SWIGSTDCALL CSharp_RobotRaconteur_WrappedPodMultiDimArrayMemoryClient_DimCount(void * jarg1) {
  unsigned long long jresult ;
  RobotRaconteur::WrappedPodMultiDimArrayMemoryClient *arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPodMultiDimArrayMemoryClient > *smartarg1 = 0 ;
  uint64_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPodMultiDimArrayMemoryClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (uint64_t)(arg1)->DimCount();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WrappedPodMultiDimArrayMemoryClient_Direction(void * jarg1) {
  int jresult ;
  RobotRaconteur::WrappedPodMultiDimArrayMemoryClient *arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPodMultiDimArrayMemoryClient > *smartarg1 = 0 ;
  RobotRaconteur::MemberDefinition_Direction result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPodMultiDimArrayMemoryClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (RobotRaconteur::MemberDefinition_Direction)(arg1)->Direction();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPodMultiDimArrayMemoryClient_Read(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  RobotRaconteur::WrappedPodMultiDimArrayMemoryClient *arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryClient *) 0 ;
  std::vector< uint64_t > *arg2 = 0 ;
  RobotRaconteur::WrappedPodMultiDimArrayMemoryClientBuffer *arg3 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryClientBuffer *) 0 ;
  std::vector< uint64_t > *arg4 = 0 ;
  std::vector< uint64_t > *arg5 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPodMultiDimArrayMemoryClient > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPodMultiDimArrayMemoryClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryClient *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< uint64_t > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return ;
  } 
  arg3 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryClientBuffer *)jarg3; 
  arg4 = (std::vector< uint64_t > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return ;
  } 
  arg5 = (std::vector< uint64_t > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->Read((std::vector< uint64_t > const &)*arg2,arg3,(std::vector< uint64_t > const &)*arg4,(std::vector< uint64_t > const &)*arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPodMultiDimArrayMemoryClient_Write(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  RobotRaconteur::WrappedPodMultiDimArrayMemoryClient *arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryClient *) 0 ;
  std::vector< uint64_t > *arg2 = 0 ;
  RobotRaconteur::WrappedPodMultiDimArrayMemoryClientBuffer *arg3 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryClientBuffer *) 0 ;
  std::vector< uint64_t > *arg4 = 0 ;
  std::vector< uint64_t > *arg5 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPodMultiDimArrayMemoryClient > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPodMultiDimArrayMemoryClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryClient *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< uint64_t > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return ;
  } 
  arg3 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryClientBuffer *)jarg3; 
  arg4 = (std::vector< uint64_t > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return ;
  } 
  arg5 = (std::vector< uint64_t > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->Write((std::vector< uint64_t > const &)*arg2,arg3,(std::vector< uint64_t > const &)*arg4,(std::vector< uint64_t > const &)*arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedPodMultiDimArrayMemoryClient(void * jarg1) {
  RobotRaconteur::WrappedPodMultiDimArrayMemoryClient *arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPodMultiDimArrayMemoryClient > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPodMultiDimArrayMemoryClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedArrayMemoryDirector(void * jarg1) {
  RobotRaconteur::WrappedArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedArrayMemoryDirector *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedArrayMemoryDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long long SWIGSTDCALL CSharp_RobotRaconteur_WrappedArrayMemoryDirector_Length(void * jarg1) {
  unsigned long long jresult ;
  RobotRaconteur::WrappedArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedArrayMemoryDirector *) 0 ;
  uint64_t result;
  
  arg1 = (RobotRaconteur::WrappedArrayMemoryDirector *)jarg1; 
  
  try {
    result = (uint64_t)(arg1)->Length();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedArrayMemoryDirector_Read(void * jarg1, unsigned long long jarg2, void * jarg3, unsigned long long jarg4, unsigned long long jarg5) {
  RobotRaconteur::WrappedArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedArrayMemoryDirector *) 0 ;
  uint64_t arg2 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > arg3 ;
  uint64_t arg4 ;
  uint64_t arg5 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg3 ;
  
  arg1 = (RobotRaconteur::WrappedArrayMemoryDirector *)jarg1; 
  arg2 = (uint64_t)jarg2; 
  
  // intrusive_ptr by value
  smartarg3 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg3;
  if (smartarg3) {
    arg3 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg3->get(), true);
  }
  
  arg4 = (uint64_t)jarg4; 
  arg5 = (uint64_t)jarg5; 
  
  try {
    (arg1)->Read(arg2,arg3,arg4,arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedArrayMemoryDirector_Write(void * jarg1, unsigned long long jarg2, void * jarg3, unsigned long long jarg4, unsigned long long jarg5) {
  RobotRaconteur::WrappedArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedArrayMemoryDirector *) 0 ;
  uint64_t arg2 ;
  boost::intrusive_ptr< RobotRaconteur::RRBaseArray > arg3 ;
  uint64_t arg4 ;
  uint64_t arg5 ;
  boost::shared_ptr< RobotRaconteur::RRBaseArray > *smartarg3 ;
  
  arg1 = (RobotRaconteur::WrappedArrayMemoryDirector *)jarg1; 
  arg2 = (uint64_t)jarg2; 
  
  // intrusive_ptr by value
  smartarg3 = *(boost::shared_ptr<  RobotRaconteur::RRBaseArray >**)&jarg3;
  if (smartarg3) {
    arg3 = boost::intrusive_ptr<  RobotRaconteur::RRBaseArray >(smartarg3->get(), true);
  }
  
  arg4 = (uint64_t)jarg4; 
  arg5 = (uint64_t)jarg5; 
  
  try {
    (arg1)->Write(arg2,arg3,arg4,arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedArrayMemoryDirector_objectheapid_set(void * jarg1, int jarg2) {
  RobotRaconteur::WrappedArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedArrayMemoryDirector *) 0 ;
  int32_t arg2 ;
  
  arg1 = (RobotRaconteur::WrappedArrayMemoryDirector *)jarg1; 
  arg2 = (int32_t)jarg2; 
  if (arg1) (arg1)->objectheapid = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WrappedArrayMemoryDirector_objectheapid_get(void * jarg1) {
  int jresult ;
  RobotRaconteur::WrappedArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedArrayMemoryDirector *) 0 ;
  int32_t result;
  
  arg1 = (RobotRaconteur::WrappedArrayMemoryDirector *)jarg1; 
  result = (int32_t) ((arg1)->objectheapid);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedArrayMemoryDirector() {
  void * jresult ;
  RobotRaconteur::WrappedArrayMemoryDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedArrayMemoryDirector *)new SwigDirector_WrappedArrayMemoryDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedArrayMemoryDirector_director_connect(void *objarg, SwigDirector_WrappedArrayMemoryDirector::SWIG_Callback0_t callback0, SwigDirector_WrappedArrayMemoryDirector::SWIG_Callback1_t callback1, SwigDirector_WrappedArrayMemoryDirector::SWIG_Callback2_t callback2) {
  RobotRaconteur::WrappedArrayMemoryDirector *obj = (RobotRaconteur::WrappedArrayMemoryDirector *)objarg;
  SwigDirector_WrappedArrayMemoryDirector *director = static_cast<SwigDirector_WrappedArrayMemoryDirector *>(obj);
  director->swig_connect_director(callback0, callback1, callback2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedMultiDimArrayMemoryParams_memorypos_set(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedMultiDimArrayMemoryParams *arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryParams *) 0 ;
  std::vector< uint64_t > *arg2 = (std::vector< uint64_t > *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryParams *)jarg1; 
  arg2 = (std::vector< uint64_t > *)jarg2; 
  if (arg1) (arg1)->memorypos = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedMultiDimArrayMemoryParams_memorypos_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedMultiDimArrayMemoryParams *arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryParams *) 0 ;
  std::vector< uint64_t > *result = 0 ;
  
  arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryParams *)jarg1; 
  result = (std::vector< uint64_t > *)& ((arg1)->memorypos);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedMultiDimArrayMemoryParams_buffer_set(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedMultiDimArrayMemoryParams *arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryParams *) 0 ;
  boost::shared_ptr< RobotRaconteur::RRMultiDimArrayUntyped > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RRMultiDimArrayUntyped > tempnull2 ;
  
  arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryParams *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::RRMultiDimArrayUntyped > *)jarg2 : &tempnull2; 
  if (arg1) (arg1)->buffer = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedMultiDimArrayMemoryParams_buffer_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedMultiDimArrayMemoryParams *arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryParams *) 0 ;
  boost::shared_ptr< RobotRaconteur::RRMultiDimArrayUntyped > *result = 0 ;
  
  arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryParams *)jarg1; 
  result = (boost::shared_ptr< RobotRaconteur::RRMultiDimArrayUntyped > *) & ((arg1)->buffer);
  jresult = *result ? new boost::shared_ptr< RobotRaconteur::RRMultiDimArrayUntyped >(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedMultiDimArrayMemoryParams_bufferpos_set(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedMultiDimArrayMemoryParams *arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryParams *) 0 ;
  std::vector< uint64_t > *arg2 = (std::vector< uint64_t > *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryParams *)jarg1; 
  arg2 = (std::vector< uint64_t > *)jarg2; 
  if (arg1) (arg1)->bufferpos = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedMultiDimArrayMemoryParams_bufferpos_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedMultiDimArrayMemoryParams *arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryParams *) 0 ;
  std::vector< uint64_t > *result = 0 ;
  
  arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryParams *)jarg1; 
  result = (std::vector< uint64_t > *)& ((arg1)->bufferpos);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedMultiDimArrayMemoryParams_count_set(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedMultiDimArrayMemoryParams *arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryParams *) 0 ;
  std::vector< uint64_t > *arg2 = (std::vector< uint64_t > *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryParams *)jarg1; 
  arg2 = (std::vector< uint64_t > *)jarg2; 
  if (arg1) (arg1)->count = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedMultiDimArrayMemoryParams_count_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedMultiDimArrayMemoryParams *arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryParams *) 0 ;
  std::vector< uint64_t > *result = 0 ;
  
  arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryParams *)jarg1; 
  result = (std::vector< uint64_t > *)& ((arg1)->count);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedMultiDimArrayMemoryParams() {
  void * jresult ;
  RobotRaconteur::WrappedMultiDimArrayMemoryParams *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedMultiDimArrayMemoryParams *)new RobotRaconteur::WrappedMultiDimArrayMemoryParams();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedMultiDimArrayMemoryParams(void * jarg1) {
  RobotRaconteur::WrappedMultiDimArrayMemoryParams *arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryParams *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryParams *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedMultiDimArrayMemoryDirector(void * jarg1) {
  RobotRaconteur::WrappedMultiDimArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryDirector *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedMultiDimArrayMemoryDirector_Dimensions(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedMultiDimArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryDirector *) 0 ;
  std::vector< uint64_t > result;
  
  arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryDirector *)jarg1; 
  
  try {
    result = (arg1)->Dimensions();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< uint64_t >((const std::vector< uint64_t > &)result); 
  return jresult;
}


SWIGEXPORT unsigned long long SWIGSTDCALL CSharp_RobotRaconteur_WrappedMultiDimArrayMemoryDirector_DimCount(void * jarg1) {
  unsigned long long jresult ;
  RobotRaconteur::WrappedMultiDimArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryDirector *) 0 ;
  uint64_t result;
  
  arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryDirector *)jarg1; 
  
  try {
    result = (uint64_t)(arg1)->DimCount();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedMultiDimArrayMemoryDirector_Read(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedMultiDimArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryDirector *) 0 ;
  RobotRaconteur::WrappedMultiDimArrayMemoryParams *arg2 = (RobotRaconteur::WrappedMultiDimArrayMemoryParams *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryDirector *)jarg1; 
  arg2 = (RobotRaconteur::WrappedMultiDimArrayMemoryParams *)jarg2; 
  
  try {
    (arg1)->Read(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedMultiDimArrayMemoryDirector_Write(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedMultiDimArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryDirector *) 0 ;
  RobotRaconteur::WrappedMultiDimArrayMemoryParams *arg2 = (RobotRaconteur::WrappedMultiDimArrayMemoryParams *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryDirector *)jarg1; 
  arg2 = (RobotRaconteur::WrappedMultiDimArrayMemoryParams *)jarg2; 
  
  try {
    (arg1)->Write(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedMultiDimArrayMemoryDirector_objectheapid_set(void * jarg1, int jarg2) {
  RobotRaconteur::WrappedMultiDimArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryDirector *) 0 ;
  int32_t arg2 ;
  
  arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryDirector *)jarg1; 
  arg2 = (int32_t)jarg2; 
  if (arg1) (arg1)->objectheapid = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WrappedMultiDimArrayMemoryDirector_objectheapid_get(void * jarg1) {
  int jresult ;
  RobotRaconteur::WrappedMultiDimArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryDirector *) 0 ;
  int32_t result;
  
  arg1 = (RobotRaconteur::WrappedMultiDimArrayMemoryDirector *)jarg1; 
  result = (int32_t) ((arg1)->objectheapid);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedMultiDimArrayMemoryDirector() {
  void * jresult ;
  RobotRaconteur::WrappedMultiDimArrayMemoryDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedMultiDimArrayMemoryDirector *)new SwigDirector_WrappedMultiDimArrayMemoryDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedMultiDimArrayMemoryDirector_director_connect(void *objarg, SwigDirector_WrappedMultiDimArrayMemoryDirector::SWIG_Callback0_t callback0, SwigDirector_WrappedMultiDimArrayMemoryDirector::SWIG_Callback1_t callback1, SwigDirector_WrappedMultiDimArrayMemoryDirector::SWIG_Callback2_t callback2, SwigDirector_WrappedMultiDimArrayMemoryDirector::SWIG_Callback3_t callback3) {
  RobotRaconteur::WrappedMultiDimArrayMemoryDirector *obj = (RobotRaconteur::WrappedMultiDimArrayMemoryDirector *)objarg;
  SwigDirector_WrappedMultiDimArrayMemoryDirector *director = static_cast<SwigDirector_WrappedMultiDimArrayMemoryDirector *>(obj);
  director->swig_connect_director(callback0, callback1, callback2, callback3);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedPodArrayMemoryDirector() {
  void * jresult ;
  RobotRaconteur::WrappedPodArrayMemoryDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedPodArrayMemoryDirector *)new SwigDirector_WrappedPodArrayMemoryDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedPodArrayMemoryDirector(void * jarg1) {
  RobotRaconteur::WrappedPodArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedPodArrayMemoryDirector *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedPodArrayMemoryDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long long SWIGSTDCALL CSharp_RobotRaconteur_WrappedPodArrayMemoryDirector_Length(void * jarg1) {
  unsigned long long jresult ;
  RobotRaconteur::WrappedPodArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedPodArrayMemoryDirector *) 0 ;
  uint64_t result;
  
  arg1 = (RobotRaconteur::WrappedPodArrayMemoryDirector *)jarg1; 
  
  try {
    result = (uint64_t)(arg1)->Length();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedPodArrayMemoryDirector_Read(void * jarg1, unsigned long long jarg2, unsigned long long jarg3, unsigned long long jarg4) {
  void * jresult ;
  RobotRaconteur::WrappedPodArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedPodArrayMemoryDirector *) 0 ;
  uint64_t arg2 ;
  uint64_t arg3 ;
  uint64_t arg4 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > result;
  
  arg1 = (RobotRaconteur::WrappedPodArrayMemoryDirector *)jarg1; 
  arg2 = (uint64_t)jarg2; 
  arg3 = (uint64_t)jarg3; 
  arg4 = (uint64_t)jarg4; 
  
  try {
    result = (arg1)->Read(arg2,arg3,arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElementNestedElementList >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPodArrayMemoryDirector_Write(void * jarg1, unsigned long long jarg2, void * jarg3, unsigned long long jarg4, unsigned long long jarg5) {
  RobotRaconteur::WrappedPodArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedPodArrayMemoryDirector *) 0 ;
  uint64_t arg2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > arg3 ;
  uint64_t arg4 ;
  uint64_t arg5 ;
  boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > *smartarg3 ;
  
  arg1 = (RobotRaconteur::WrappedPodArrayMemoryDirector *)jarg1; 
  arg2 = (uint64_t)jarg2; 
  
  // intrusive_ptr by value
  smartarg3 = *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList >**)&jarg3;
  if (smartarg3) {
    arg3 = boost::intrusive_ptr<  RobotRaconteur::MessageElementNestedElementList >(smartarg3->get(), true);
  }
  
  arg4 = (uint64_t)jarg4; 
  arg5 = (uint64_t)jarg5; 
  
  try {
    (arg1)->Write(arg2,arg3,arg4,arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPodArrayMemoryDirector_objectheapid_set(void * jarg1, int jarg2) {
  RobotRaconteur::WrappedPodArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedPodArrayMemoryDirector *) 0 ;
  int32_t arg2 ;
  
  arg1 = (RobotRaconteur::WrappedPodArrayMemoryDirector *)jarg1; 
  arg2 = (int32_t)jarg2; 
  if (arg1) (arg1)->objectheapid = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WrappedPodArrayMemoryDirector_objectheapid_get(void * jarg1) {
  int jresult ;
  RobotRaconteur::WrappedPodArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedPodArrayMemoryDirector *) 0 ;
  int32_t result;
  
  arg1 = (RobotRaconteur::WrappedPodArrayMemoryDirector *)jarg1; 
  result = (int32_t) ((arg1)->objectheapid);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPodArrayMemoryDirector_director_connect(void *objarg, SwigDirector_WrappedPodArrayMemoryDirector::SWIG_Callback0_t callback0, SwigDirector_WrappedPodArrayMemoryDirector::SWIG_Callback1_t callback1, SwigDirector_WrappedPodArrayMemoryDirector::SWIG_Callback2_t callback2) {
  RobotRaconteur::WrappedPodArrayMemoryDirector *obj = (RobotRaconteur::WrappedPodArrayMemoryDirector *)objarg;
  SwigDirector_WrappedPodArrayMemoryDirector *director = static_cast<SwigDirector_WrappedPodArrayMemoryDirector *>(obj);
  director->swig_connect_director(callback0, callback1, callback2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedPodMultiDimArrayMemoryDirector(void * jarg1) {
  RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedPodMultiDimArrayMemoryDirector_Dimensions(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector *) 0 ;
  std::vector< uint64_t > result;
  
  arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector *)jarg1; 
  
  try {
    result = (arg1)->Dimensions();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< uint64_t >((const std::vector< uint64_t > &)result); 
  return jresult;
}


SWIGEXPORT unsigned long long SWIGSTDCALL CSharp_RobotRaconteur_WrappedPodMultiDimArrayMemoryDirector_DimCount(void * jarg1) {
  unsigned long long jresult ;
  RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector *) 0 ;
  uint64_t result;
  
  arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector *)jarg1; 
  
  try {
    result = (uint64_t)(arg1)->DimCount();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedPodMultiDimArrayMemoryDirector_Read(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector *) 0 ;
  std::vector< uint64_t > *arg2 = 0 ;
  std::vector< uint64_t > *arg3 = 0 ;
  std::vector< uint64_t > *arg4 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > result;
  
  arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector *)jarg1; 
  arg2 = (std::vector< uint64_t > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< uint64_t > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< uint64_t > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (arg1)->Read((std::vector< uint64_t > const &)*arg2,(std::vector< uint64_t > const &)*arg3,(std::vector< uint64_t > const &)*arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElementNestedElementList >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPodMultiDimArrayMemoryDirector_Write(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector *) 0 ;
  std::vector< uint64_t > *arg2 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > arg3 ;
  std::vector< uint64_t > *arg4 = 0 ;
  std::vector< uint64_t > *arg5 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > *smartarg3 ;
  
  arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector *)jarg1; 
  arg2 = (std::vector< uint64_t > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return ;
  } 
  
  // intrusive_ptr by value
  smartarg3 = *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList >**)&jarg3;
  if (smartarg3) {
    arg3 = boost::intrusive_ptr<  RobotRaconteur::MessageElementNestedElementList >(smartarg3->get(), true);
  }
  
  arg4 = (std::vector< uint64_t > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return ;
  } 
  arg5 = (std::vector< uint64_t > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->Write((std::vector< uint64_t > const &)*arg2,arg3,(std::vector< uint64_t > const &)*arg4,(std::vector< uint64_t > const &)*arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPodMultiDimArrayMemoryDirector_objectheapid_set(void * jarg1, int jarg2) {
  RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector *) 0 ;
  int32_t arg2 ;
  
  arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector *)jarg1; 
  arg2 = (int32_t)jarg2; 
  if (arg1) (arg1)->objectheapid = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WrappedPodMultiDimArrayMemoryDirector_objectheapid_get(void * jarg1) {
  int jresult ;
  RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector *) 0 ;
  int32_t result;
  
  arg1 = (RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector *)jarg1; 
  result = (int32_t) ((arg1)->objectheapid);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedPodMultiDimArrayMemoryDirector() {
  void * jresult ;
  RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector *)new SwigDirector_WrappedPodMultiDimArrayMemoryDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPodMultiDimArrayMemoryDirector_director_connect(void *objarg, SwigDirector_WrappedPodMultiDimArrayMemoryDirector::SWIG_Callback0_t callback0, SwigDirector_WrappedPodMultiDimArrayMemoryDirector::SWIG_Callback1_t callback1, SwigDirector_WrappedPodMultiDimArrayMemoryDirector::SWIG_Callback2_t callback2, SwigDirector_WrappedPodMultiDimArrayMemoryDirector::SWIG_Callback3_t callback3) {
  RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector *obj = (RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector *)objarg;
  SwigDirector_WrappedPodMultiDimArrayMemoryDirector *director = static_cast<SwigDirector_WrappedPodMultiDimArrayMemoryDirector *>(obj);
  director->swig_connect_director(callback0, callback1, callback2, callback3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedNamedArrayMemoryClientBuffer_UnpackReadResult(void * jarg1, void * jarg2, unsigned long long jarg3, unsigned long long jarg4) {
  RobotRaconteur::WrappedNamedArrayMemoryClientBuffer *arg1 = (RobotRaconteur::WrappedNamedArrayMemoryClientBuffer *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > arg2 ;
  uint64_t arg3 ;
  uint64_t arg4 ;
  boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > *smartarg2 ;
  
  arg1 = (RobotRaconteur::WrappedNamedArrayMemoryClientBuffer *)jarg1; 
  
  // intrusive_ptr by value
  smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList >**)&jarg2;
  if (smartarg2) {
    arg2 = boost::intrusive_ptr<  RobotRaconteur::MessageElementNestedElementList >(smartarg2->get(), true);
  }
  
  arg3 = (uint64_t)jarg3; 
  arg4 = (uint64_t)jarg4; 
  
  try {
    (arg1)->UnpackReadResult(arg2,arg3,arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedNamedArrayMemoryClientBuffer_PackWriteRequest(void * jarg1, unsigned long long jarg2, unsigned long long jarg3) {
  void * jresult ;
  RobotRaconteur::WrappedNamedArrayMemoryClientBuffer *arg1 = (RobotRaconteur::WrappedNamedArrayMemoryClientBuffer *) 0 ;
  uint64_t arg2 ;
  uint64_t arg3 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > result;
  
  arg1 = (RobotRaconteur::WrappedNamedArrayMemoryClientBuffer *)jarg1; 
  arg2 = (uint64_t)jarg2; 
  arg3 = (uint64_t)jarg3; 
  
  try {
    result = (arg1)->PackWriteRequest(arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElementNestedElementList >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT unsigned long long SWIGSTDCALL CSharp_RobotRaconteur_WrappedNamedArrayMemoryClientBuffer_GetBufferLength(void * jarg1) {
  unsigned long long jresult ;
  RobotRaconteur::WrappedNamedArrayMemoryClientBuffer *arg1 = (RobotRaconteur::WrappedNamedArrayMemoryClientBuffer *) 0 ;
  uint64_t result;
  
  arg1 = (RobotRaconteur::WrappedNamedArrayMemoryClientBuffer *)jarg1; 
  
  try {
    result = (uint64_t)(arg1)->GetBufferLength();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedNamedArrayMemoryClientBuffer(void * jarg1) {
  RobotRaconteur::WrappedNamedArrayMemoryClientBuffer *arg1 = (RobotRaconteur::WrappedNamedArrayMemoryClientBuffer *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedNamedArrayMemoryClientBuffer *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedNamedArrayMemoryClientBuffer() {
  void * jresult ;
  RobotRaconteur::WrappedNamedArrayMemoryClientBuffer *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedNamedArrayMemoryClientBuffer *)new SwigDirector_WrappedNamedArrayMemoryClientBuffer();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedNamedArrayMemoryClientBuffer_director_connect(void *objarg, SwigDirector_WrappedNamedArrayMemoryClientBuffer::SWIG_Callback0_t callback0, SwigDirector_WrappedNamedArrayMemoryClientBuffer::SWIG_Callback1_t callback1, SwigDirector_WrappedNamedArrayMemoryClientBuffer::SWIG_Callback2_t callback2) {
  RobotRaconteur::WrappedNamedArrayMemoryClientBuffer *obj = (RobotRaconteur::WrappedNamedArrayMemoryClientBuffer *)objarg;
  SwigDirector_WrappedNamedArrayMemoryClientBuffer *director = static_cast<SwigDirector_WrappedNamedArrayMemoryClientBuffer *>(obj);
  director->swig_connect_director(callback0, callback1, callback2);
}


SWIGEXPORT unsigned long long SWIGSTDCALL CSharp_RobotRaconteur_WrappedNamedArrayMemoryClient_Length(void * jarg1) {
  unsigned long long jresult ;
  RobotRaconteur::WrappedNamedArrayMemoryClient *arg1 = (RobotRaconteur::WrappedNamedArrayMemoryClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedNamedArrayMemoryClient > *smartarg1 = 0 ;
  uint64_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedNamedArrayMemoryClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedNamedArrayMemoryClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (uint64_t)(arg1)->Length();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WrappedNamedArrayMemoryClient_Direction(void * jarg1) {
  int jresult ;
  RobotRaconteur::WrappedNamedArrayMemoryClient *arg1 = (RobotRaconteur::WrappedNamedArrayMemoryClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedNamedArrayMemoryClient > *smartarg1 = 0 ;
  RobotRaconteur::MemberDefinition_Direction result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedNamedArrayMemoryClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedNamedArrayMemoryClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (RobotRaconteur::MemberDefinition_Direction)(arg1)->Direction();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedNamedArrayMemoryClient_Read(void * jarg1, unsigned long long jarg2, void * jarg3, unsigned long long jarg4, unsigned long long jarg5) {
  RobotRaconteur::WrappedNamedArrayMemoryClient *arg1 = (RobotRaconteur::WrappedNamedArrayMemoryClient *) 0 ;
  uint64_t arg2 ;
  RobotRaconteur::WrappedNamedArrayMemoryClientBuffer *arg3 = (RobotRaconteur::WrappedNamedArrayMemoryClientBuffer *) 0 ;
  uint64_t arg4 ;
  uint64_t arg5 ;
  boost::shared_ptr< RobotRaconteur::WrappedNamedArrayMemoryClient > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedNamedArrayMemoryClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedNamedArrayMemoryClient *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (uint64_t)jarg2; 
  arg3 = (RobotRaconteur::WrappedNamedArrayMemoryClientBuffer *)jarg3; 
  arg4 = (uint64_t)jarg4; 
  arg5 = (uint64_t)jarg5; 
  
  try {
    (arg1)->Read(arg2,arg3,arg4,arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedNamedArrayMemoryClient_Write(void * jarg1, unsigned long long jarg2, void * jarg3, unsigned long long jarg4, unsigned long long jarg5) {
  RobotRaconteur::WrappedNamedArrayMemoryClient *arg1 = (RobotRaconteur::WrappedNamedArrayMemoryClient *) 0 ;
  uint64_t arg2 ;
  RobotRaconteur::WrappedNamedArrayMemoryClientBuffer *arg3 = (RobotRaconteur::WrappedNamedArrayMemoryClientBuffer *) 0 ;
  uint64_t arg4 ;
  uint64_t arg5 ;
  boost::shared_ptr< RobotRaconteur::WrappedNamedArrayMemoryClient > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedNamedArrayMemoryClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedNamedArrayMemoryClient *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (uint64_t)jarg2; 
  arg3 = (RobotRaconteur::WrappedNamedArrayMemoryClientBuffer *)jarg3; 
  arg4 = (uint64_t)jarg4; 
  arg5 = (uint64_t)jarg5; 
  
  try {
    (arg1)->Write(arg2,arg3,arg4,arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedNamedArrayMemoryClient(void * jarg1) {
  RobotRaconteur::WrappedNamedArrayMemoryClient *arg1 = (RobotRaconteur::WrappedNamedArrayMemoryClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedNamedArrayMemoryClient > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedNamedArrayMemoryClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedNamedArrayMemoryClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedNamedMultiDimArrayMemoryClientBuffer_UnpackReadResult(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  RobotRaconteur::WrappedNamedMultiDimArrayMemoryClientBuffer *arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryClientBuffer *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > arg2 ;
  std::vector< uint64_t > *arg3 = 0 ;
  std::vector< uint64_t > *arg4 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > *smartarg2 ;
  
  arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryClientBuffer *)jarg1; 
  
  // intrusive_ptr by value
  smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList >**)&jarg2;
  if (smartarg2) {
    arg2 = boost::intrusive_ptr<  RobotRaconteur::MessageElementNestedElementList >(smartarg2->get(), true);
  }
  
  arg3 = (std::vector< uint64_t > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return ;
  } 
  arg4 = (std::vector< uint64_t > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->UnpackReadResult(arg2,(std::vector< uint64_t > const &)*arg3,(std::vector< uint64_t > const &)*arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedNamedMultiDimArrayMemoryClientBuffer_PackWriteRequest(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  RobotRaconteur::WrappedNamedMultiDimArrayMemoryClientBuffer *arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryClientBuffer *) 0 ;
  std::vector< uint64_t > *arg2 = 0 ;
  std::vector< uint64_t > *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > result;
  
  arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryClientBuffer *)jarg1; 
  arg2 = (std::vector< uint64_t > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< uint64_t > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (arg1)->PackWriteRequest((std::vector< uint64_t > const &)*arg2,(std::vector< uint64_t > const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElementNestedElementList >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedNamedMultiDimArrayMemoryClientBuffer(void * jarg1) {
  RobotRaconteur::WrappedNamedMultiDimArrayMemoryClientBuffer *arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryClientBuffer *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryClientBuffer *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedNamedMultiDimArrayMemoryClientBuffer() {
  void * jresult ;
  RobotRaconteur::WrappedNamedMultiDimArrayMemoryClientBuffer *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryClientBuffer *)new SwigDirector_WrappedNamedMultiDimArrayMemoryClientBuffer();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedNamedMultiDimArrayMemoryClientBuffer_director_connect(void *objarg, SwigDirector_WrappedNamedMultiDimArrayMemoryClientBuffer::SWIG_Callback0_t callback0, SwigDirector_WrappedNamedMultiDimArrayMemoryClientBuffer::SWIG_Callback1_t callback1) {
  RobotRaconteur::WrappedNamedMultiDimArrayMemoryClientBuffer *obj = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryClientBuffer *)objarg;
  SwigDirector_WrappedNamedMultiDimArrayMemoryClientBuffer *director = static_cast<SwigDirector_WrappedNamedMultiDimArrayMemoryClientBuffer *>(obj);
  director->swig_connect_director(callback0, callback1);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedNamedMultiDimArrayMemoryClient_Dimensions(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient *arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient > *smartarg1 = 0 ;
  std::vector< uint64_t > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->Dimensions();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< uint64_t >((const std::vector< uint64_t > &)result); 
  return jresult;
}


SWIGEXPORT unsigned long long SWIGSTDCALL CSharp_RobotRaconteur_WrappedNamedMultiDimArrayMemoryClient_DimCount(void * jarg1) {
  unsigned long long jresult ;
  RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient *arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient > *smartarg1 = 0 ;
  uint64_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (uint64_t)(arg1)->DimCount();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WrappedNamedMultiDimArrayMemoryClient_Direction(void * jarg1) {
  int jresult ;
  RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient *arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient > *smartarg1 = 0 ;
  RobotRaconteur::MemberDefinition_Direction result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (RobotRaconteur::MemberDefinition_Direction)(arg1)->Direction();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedNamedMultiDimArrayMemoryClient_Read(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient *arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient *) 0 ;
  std::vector< uint64_t > *arg2 = 0 ;
  RobotRaconteur::WrappedNamedMultiDimArrayMemoryClientBuffer *arg3 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryClientBuffer *) 0 ;
  std::vector< uint64_t > *arg4 = 0 ;
  std::vector< uint64_t > *arg5 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< uint64_t > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return ;
  } 
  arg3 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryClientBuffer *)jarg3; 
  arg4 = (std::vector< uint64_t > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return ;
  } 
  arg5 = (std::vector< uint64_t > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->Read((std::vector< uint64_t > const &)*arg2,arg3,(std::vector< uint64_t > const &)*arg4,(std::vector< uint64_t > const &)*arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedNamedMultiDimArrayMemoryClient_Write(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient *arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient *) 0 ;
  std::vector< uint64_t > *arg2 = 0 ;
  RobotRaconteur::WrappedNamedMultiDimArrayMemoryClientBuffer *arg3 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryClientBuffer *) 0 ;
  std::vector< uint64_t > *arg4 = 0 ;
  std::vector< uint64_t > *arg5 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< uint64_t > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return ;
  } 
  arg3 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryClientBuffer *)jarg3; 
  arg4 = (std::vector< uint64_t > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return ;
  } 
  arg5 = (std::vector< uint64_t > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->Write((std::vector< uint64_t > const &)*arg2,arg3,(std::vector< uint64_t > const &)*arg4,(std::vector< uint64_t > const &)*arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedNamedMultiDimArrayMemoryClient(void * jarg1) {
  RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient *arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedNamedArrayMemoryDirector() {
  void * jresult ;
  RobotRaconteur::WrappedNamedArrayMemoryDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedNamedArrayMemoryDirector *)new SwigDirector_WrappedNamedArrayMemoryDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedNamedArrayMemoryDirector(void * jarg1) {
  RobotRaconteur::WrappedNamedArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedNamedArrayMemoryDirector *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedNamedArrayMemoryDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long long SWIGSTDCALL CSharp_RobotRaconteur_WrappedNamedArrayMemoryDirector_Length(void * jarg1) {
  unsigned long long jresult ;
  RobotRaconteur::WrappedNamedArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedNamedArrayMemoryDirector *) 0 ;
  uint64_t result;
  
  arg1 = (RobotRaconteur::WrappedNamedArrayMemoryDirector *)jarg1; 
  
  try {
    result = (uint64_t)(arg1)->Length();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedNamedArrayMemoryDirector_Read(void * jarg1, unsigned long long jarg2, unsigned long long jarg3, unsigned long long jarg4) {
  void * jresult ;
  RobotRaconteur::WrappedNamedArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedNamedArrayMemoryDirector *) 0 ;
  uint64_t arg2 ;
  uint64_t arg3 ;
  uint64_t arg4 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > result;
  
  arg1 = (RobotRaconteur::WrappedNamedArrayMemoryDirector *)jarg1; 
  arg2 = (uint64_t)jarg2; 
  arg3 = (uint64_t)jarg3; 
  arg4 = (uint64_t)jarg4; 
  
  try {
    result = (arg1)->Read(arg2,arg3,arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElementNestedElementList >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedNamedArrayMemoryDirector_Write(void * jarg1, unsigned long long jarg2, void * jarg3, unsigned long long jarg4, unsigned long long jarg5) {
  RobotRaconteur::WrappedNamedArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedNamedArrayMemoryDirector *) 0 ;
  uint64_t arg2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > arg3 ;
  uint64_t arg4 ;
  uint64_t arg5 ;
  boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > *smartarg3 ;
  
  arg1 = (RobotRaconteur::WrappedNamedArrayMemoryDirector *)jarg1; 
  arg2 = (uint64_t)jarg2; 
  
  // intrusive_ptr by value
  smartarg3 = *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList >**)&jarg3;
  if (smartarg3) {
    arg3 = boost::intrusive_ptr<  RobotRaconteur::MessageElementNestedElementList >(smartarg3->get(), true);
  }
  
  arg4 = (uint64_t)jarg4; 
  arg5 = (uint64_t)jarg5; 
  
  try {
    (arg1)->Write(arg2,arg3,arg4,arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedNamedArrayMemoryDirector_objectheapid_set(void * jarg1, int jarg2) {
  RobotRaconteur::WrappedNamedArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedNamedArrayMemoryDirector *) 0 ;
  int32_t arg2 ;
  
  arg1 = (RobotRaconteur::WrappedNamedArrayMemoryDirector *)jarg1; 
  arg2 = (int32_t)jarg2; 
  if (arg1) (arg1)->objectheapid = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WrappedNamedArrayMemoryDirector_objectheapid_get(void * jarg1) {
  int jresult ;
  RobotRaconteur::WrappedNamedArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedNamedArrayMemoryDirector *) 0 ;
  int32_t result;
  
  arg1 = (RobotRaconteur::WrappedNamedArrayMemoryDirector *)jarg1; 
  result = (int32_t) ((arg1)->objectheapid);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedNamedArrayMemoryDirector_director_connect(void *objarg, SwigDirector_WrappedNamedArrayMemoryDirector::SWIG_Callback0_t callback0, SwigDirector_WrappedNamedArrayMemoryDirector::SWIG_Callback1_t callback1, SwigDirector_WrappedNamedArrayMemoryDirector::SWIG_Callback2_t callback2) {
  RobotRaconteur::WrappedNamedArrayMemoryDirector *obj = (RobotRaconteur::WrappedNamedArrayMemoryDirector *)objarg;
  SwigDirector_WrappedNamedArrayMemoryDirector *director = static_cast<SwigDirector_WrappedNamedArrayMemoryDirector *>(obj);
  director->swig_connect_director(callback0, callback1, callback2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedNamedMultiDimArrayMemoryDirector(void * jarg1) {
  RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedNamedMultiDimArrayMemoryDirector_Dimensions(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector *) 0 ;
  std::vector< uint64_t > result;
  
  arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector *)jarg1; 
  
  try {
    result = (arg1)->Dimensions();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< uint64_t >((const std::vector< uint64_t > &)result); 
  return jresult;
}


SWIGEXPORT unsigned long long SWIGSTDCALL CSharp_RobotRaconteur_WrappedNamedMultiDimArrayMemoryDirector_DimCount(void * jarg1) {
  unsigned long long jresult ;
  RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector *) 0 ;
  uint64_t result;
  
  arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector *)jarg1; 
  
  try {
    result = (uint64_t)(arg1)->DimCount();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedNamedMultiDimArrayMemoryDirector_Read(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector *) 0 ;
  std::vector< uint64_t > *arg2 = 0 ;
  std::vector< uint64_t > *arg3 = 0 ;
  std::vector< uint64_t > *arg4 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > result;
  
  arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector *)jarg1; 
  arg2 = (std::vector< uint64_t > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< uint64_t > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< uint64_t > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (arg1)->Read((std::vector< uint64_t > const &)*arg2,(std::vector< uint64_t > const &)*arg3,(std::vector< uint64_t > const &)*arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElementNestedElementList >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedNamedMultiDimArrayMemoryDirector_Write(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector *) 0 ;
  std::vector< uint64_t > *arg2 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementNestedElementList > arg3 ;
  std::vector< uint64_t > *arg4 = 0 ;
  std::vector< uint64_t > *arg5 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > *smartarg3 ;
  
  arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector *)jarg1; 
  arg2 = (std::vector< uint64_t > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return ;
  } 
  
  // intrusive_ptr by value
  smartarg3 = *(boost::shared_ptr<  RobotRaconteur::MessageElementNestedElementList >**)&jarg3;
  if (smartarg3) {
    arg3 = boost::intrusive_ptr<  RobotRaconteur::MessageElementNestedElementList >(smartarg3->get(), true);
  }
  
  arg4 = (std::vector< uint64_t > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return ;
  } 
  arg5 = (std::vector< uint64_t > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< uint64_t > const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->Write((std::vector< uint64_t > const &)*arg2,arg3,(std::vector< uint64_t > const &)*arg4,(std::vector< uint64_t > const &)*arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedNamedMultiDimArrayMemoryDirector_objectheapid_set(void * jarg1, int jarg2) {
  RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector *) 0 ;
  int32_t arg2 ;
  
  arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector *)jarg1; 
  arg2 = (int32_t)jarg2; 
  if (arg1) (arg1)->objectheapid = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WrappedNamedMultiDimArrayMemoryDirector_objectheapid_get(void * jarg1) {
  int jresult ;
  RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector *arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector *) 0 ;
  int32_t result;
  
  arg1 = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector *)jarg1; 
  result = (int32_t) ((arg1)->objectheapid);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedNamedMultiDimArrayMemoryDirector() {
  void * jresult ;
  RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector *)new SwigDirector_WrappedNamedMultiDimArrayMemoryDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedNamedMultiDimArrayMemoryDirector_director_connect(void *objarg, SwigDirector_WrappedNamedMultiDimArrayMemoryDirector::SWIG_Callback0_t callback0, SwigDirector_WrappedNamedMultiDimArrayMemoryDirector::SWIG_Callback1_t callback1, SwigDirector_WrappedNamedMultiDimArrayMemoryDirector::SWIG_Callback2_t callback2, SwigDirector_WrappedNamedMultiDimArrayMemoryDirector::SWIG_Callback3_t callback3) {
  RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector *obj = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector *)objarg;
  SwigDirector_WrappedNamedMultiDimArrayMemoryDirector *director = static_cast<SwigDirector_WrappedNamedMultiDimArrayMemoryDirector *>(obj);
  director->swig_connect_director(callback0, callback1, callback2, callback3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedGeneratorClient_TryGetNextResult_value_set(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedGeneratorClient_TryGetNextResult *arg1 = (RobotRaconteur::WrappedGeneratorClient_TryGetNextResult *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *arg2 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > temp2 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg2 ;
  
  arg1 = (RobotRaconteur::WrappedGeneratorClient_TryGetNextResult *)jarg1; 
  
  // intrusive_ptr by reference
  if ( jarg2 ) {
    smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg2;
    temp2 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg2->get(), true);
    arg2 = &temp2;
  } else {
    arg2 = &tempnull2;
  }
  
  if (arg1) (arg1)->value = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedGeneratorClient_TryGetNextResult_value_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedGeneratorClient_TryGetNextResult *arg1 = (RobotRaconteur::WrappedGeneratorClient_TryGetNextResult *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *result = 0 ;
  
  arg1 = (RobotRaconteur::WrappedGeneratorClient_TryGetNextResult *)jarg1; 
  result = (boost::intrusive_ptr< RobotRaconteur::MessageElement > *) & ((arg1)->value);
  
  if (*result) {
    intrusive_ptr_add_ref(result->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >(result->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedGeneratorClient_TryGetNextResult_res_set(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::WrappedGeneratorClient_TryGetNextResult *arg1 = (RobotRaconteur::WrappedGeneratorClient_TryGetNextResult *) 0 ;
  bool arg2 ;
  
  arg1 = (RobotRaconteur::WrappedGeneratorClient_TryGetNextResult *)jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->res = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedGeneratorClient_TryGetNextResult_res_get(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::WrappedGeneratorClient_TryGetNextResult *arg1 = (RobotRaconteur::WrappedGeneratorClient_TryGetNextResult *) 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::WrappedGeneratorClient_TryGetNextResult *)jarg1; 
  result = (bool) ((arg1)->res);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedGeneratorClient_TryGetNextResult(void * jarg1) {
  RobotRaconteur::WrappedGeneratorClient_TryGetNextResult *arg1 = (RobotRaconteur::WrappedGeneratorClient_TryGetNextResult *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedGeneratorClient_TryGetNextResult *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedGeneratorClient_Next(void * jarg1, void * jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedGeneratorClient *arg1 = (RobotRaconteur::WrappedGeneratorClient *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedGeneratorClient > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > temp2 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedGeneratorClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedGeneratorClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  // intrusive_ptr by reference
  if ( jarg2 ) {
    smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg2;
    temp2 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg2->get(), true);
    arg2 = &temp2;
  } else {
    arg2 = &tempnull2;
  }
  
  
  try {
    result = (arg1)->Next((boost::intrusive_ptr< RobotRaconteur::MessageElement > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedGeneratorClient_TryNext(void * jarg1, void * jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedGeneratorClient *arg1 = (RobotRaconteur::WrappedGeneratorClient *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedGeneratorClient > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > temp2 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg2 ;
  RobotRaconteur::WrappedGeneratorClient_TryGetNextResult result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedGeneratorClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedGeneratorClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  // intrusive_ptr by reference
  if ( jarg2 ) {
    smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg2;
    temp2 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg2->get(), true);
    arg2 = &temp2;
  } else {
    arg2 = &tempnull2;
  }
  
  
  try {
    result = (arg1)->TryNext((boost::intrusive_ptr< RobotRaconteur::MessageElement > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::WrappedGeneratorClient_TryGetNextResult((const RobotRaconteur::WrappedGeneratorClient_TryGetNextResult &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedGeneratorClient_AsyncNext(void * jarg1, void * jarg2, int jarg3, void * jarg4, int jarg5) {
  RobotRaconteur::WrappedGeneratorClient *arg1 = (RobotRaconteur::WrappedGeneratorClient *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *arg2 = 0 ;
  int32_t arg3 ;
  RobotRaconteur::AsyncRequestDirector *arg4 = (RobotRaconteur::AsyncRequestDirector *) 0 ;
  int32_t arg5 ;
  boost::shared_ptr< RobotRaconteur::WrappedGeneratorClient > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > temp2 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedGeneratorClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedGeneratorClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  // intrusive_ptr by reference
  if ( jarg2 ) {
    smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg2;
    temp2 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg2->get(), true);
    arg2 = &temp2;
  } else {
    arg2 = &tempnull2;
  }
  
  arg3 = (int32_t)jarg3; 
  arg4 = (RobotRaconteur::AsyncRequestDirector *)jarg4; 
  arg5 = (int32_t)jarg5; 
  
  try {
    (arg1)->AsyncNext((boost::intrusive_ptr< RobotRaconteur::MessageElement > const &)*arg2,arg3,arg4,arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedGeneratorClient_Abort(void * jarg1) {
  RobotRaconteur::WrappedGeneratorClient *arg1 = (RobotRaconteur::WrappedGeneratorClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedGeneratorClient > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedGeneratorClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedGeneratorClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->Abort();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedGeneratorClient_AsyncAbort(void * jarg1, int jarg2, void * jarg3, int jarg4) {
  RobotRaconteur::WrappedGeneratorClient *arg1 = (RobotRaconteur::WrappedGeneratorClient *) 0 ;
  int32_t arg2 ;
  RobotRaconteur::AsyncVoidReturnDirector *arg3 = (RobotRaconteur::AsyncVoidReturnDirector *) 0 ;
  int32_t arg4 ;
  boost::shared_ptr< RobotRaconteur::WrappedGeneratorClient > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedGeneratorClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedGeneratorClient *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  arg3 = (RobotRaconteur::AsyncVoidReturnDirector *)jarg3; 
  arg4 = (int32_t)jarg4; 
  
  try {
    (arg1)->AsyncAbort(arg2,arg3,arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedGeneratorClient_Close(void * jarg1) {
  RobotRaconteur::WrappedGeneratorClient *arg1 = (RobotRaconteur::WrappedGeneratorClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedGeneratorClient > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedGeneratorClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedGeneratorClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->Close();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedGeneratorClient_AsyncClose(void * jarg1, int jarg2, void * jarg3, int jarg4) {
  RobotRaconteur::WrappedGeneratorClient *arg1 = (RobotRaconteur::WrappedGeneratorClient *) 0 ;
  int32_t arg2 ;
  RobotRaconteur::AsyncVoidReturnDirector *arg3 = (RobotRaconteur::AsyncVoidReturnDirector *) 0 ;
  int32_t arg4 ;
  boost::shared_ptr< RobotRaconteur::WrappedGeneratorClient > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedGeneratorClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedGeneratorClient *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  arg3 = (RobotRaconteur::AsyncVoidReturnDirector *)jarg3; 
  arg4 = (int32_t)jarg4; 
  
  try {
    (arg1)->AsyncClose(arg2,arg3,arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedGeneratorClient_NextAll(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedGeneratorClient *arg1 = (RobotRaconteur::WrappedGeneratorClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedGeneratorClient > *smartarg1 = 0 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedGeneratorClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedGeneratorClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->NextAll();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > >((const std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedGeneratorClient(void * jarg1) {
  RobotRaconteur::WrappedGeneratorClient *arg1 = (RobotRaconteur::WrappedGeneratorClient *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedGeneratorClient > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedGeneratorClient > *)jarg1;
  arg1 = (RobotRaconteur::WrappedGeneratorClient *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_AsyncGeneratorClientReturnDirector(void * jarg1) {
  RobotRaconteur::AsyncGeneratorClientReturnDirector *arg1 = (RobotRaconteur::AsyncGeneratorClientReturnDirector *) 0 ;
  
  arg1 = (RobotRaconteur::AsyncGeneratorClientReturnDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AsyncGeneratorClientReturnDirector_handler(void * jarg1, void * jarg2, void * jarg3) {
  RobotRaconteur::AsyncGeneratorClientReturnDirector *arg1 = (RobotRaconteur::AsyncGeneratorClientReturnDirector *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedGeneratorClient > *arg2 = 0 ;
  RobotRaconteur::HandlerErrorInfo *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedGeneratorClient > tempnull2 ;
  
  arg1 = (RobotRaconteur::AsyncGeneratorClientReturnDirector *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedGeneratorClient > *)jarg2 : &tempnull2; 
  arg3 = (RobotRaconteur::HandlerErrorInfo *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::HandlerErrorInfo & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->handler((boost::shared_ptr< RobotRaconteur::WrappedGeneratorClient > const &)*arg2,*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_AsyncGeneratorClientReturnDirector() {
  void * jresult ;
  RobotRaconteur::AsyncGeneratorClientReturnDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::AsyncGeneratorClientReturnDirector *)new SwigDirector_AsyncGeneratorClientReturnDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AsyncGeneratorClientReturnDirector_director_connect(void *objarg, SwigDirector_AsyncGeneratorClientReturnDirector::SWIG_Callback0_t callback0) {
  RobotRaconteur::AsyncGeneratorClientReturnDirector *obj = (RobotRaconteur::AsyncGeneratorClientReturnDirector *)objarg;
  SwigDirector_AsyncGeneratorClientReturnDirector *director = static_cast<SwigDirector_AsyncGeneratorClientReturnDirector *>(obj);
  director->swig_connect_director(callback0);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedGeneratorServerDirector() {
  void * jresult ;
  RobotRaconteur::WrappedGeneratorServerDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedGeneratorServerDirector *)new SwigDirector_WrappedGeneratorServerDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedGeneratorServerDirector(void * jarg1) {
  RobotRaconteur::WrappedGeneratorServerDirector *arg1 = (RobotRaconteur::WrappedGeneratorServerDirector *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedGeneratorServerDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedGeneratorServerDirector_Next(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  RobotRaconteur::WrappedGeneratorServerDirector *arg1 = (RobotRaconteur::WrappedGeneratorServerDirector *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > tempnull3 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > result;
  
  arg1 = (RobotRaconteur::WrappedGeneratorServerDirector *)jarg1; 
  
  // intrusive_ptr by value
  smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg2;
  if (smartarg2) {
    arg2 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg2->get(), true);
  }
  
  arg3 = jarg3 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > *)jarg3 : &tempnull3; 
  
  try {
    result = (arg1)->Next(arg2,(boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedGeneratorServerDirector_Abort(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedGeneratorServerDirector *arg1 = (RobotRaconteur::WrappedGeneratorServerDirector *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > tempnull2 ;
  
  arg1 = (RobotRaconteur::WrappedGeneratorServerDirector *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > *)jarg2 : &tempnull2; 
  
  try {
    (arg1)->Abort((boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedGeneratorServerDirector_Close(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedGeneratorServerDirector *arg1 = (RobotRaconteur::WrappedGeneratorServerDirector *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > tempnull2 ;
  
  arg1 = (RobotRaconteur::WrappedGeneratorServerDirector *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > *)jarg2 : &tempnull2; 
  
  try {
    (arg1)->Close((boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedGeneratorServerDirector_objectheapid_set(void * jarg1, int jarg2) {
  RobotRaconteur::WrappedGeneratorServerDirector *arg1 = (RobotRaconteur::WrappedGeneratorServerDirector *) 0 ;
  int32_t arg2 ;
  
  arg1 = (RobotRaconteur::WrappedGeneratorServerDirector *)jarg1; 
  arg2 = (int32_t)jarg2; 
  if (arg1) (arg1)->objectheapid = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WrappedGeneratorServerDirector_objectheapid_get(void * jarg1) {
  int jresult ;
  RobotRaconteur::WrappedGeneratorServerDirector *arg1 = (RobotRaconteur::WrappedGeneratorServerDirector *) 0 ;
  int32_t result;
  
  arg1 = (RobotRaconteur::WrappedGeneratorServerDirector *)jarg1; 
  result = (int32_t) ((arg1)->objectheapid);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedGeneratorServerDirector_director_connect(void *objarg, SwigDirector_WrappedGeneratorServerDirector::SWIG_Callback0_t callback0, SwigDirector_WrappedGeneratorServerDirector::SWIG_Callback1_t callback1, SwigDirector_WrappedGeneratorServerDirector::SWIG_Callback2_t callback2) {
  RobotRaconteur::WrappedGeneratorServerDirector *obj = (RobotRaconteur::WrappedGeneratorServerDirector *)objarg;
  SwigDirector_WrappedGeneratorServerDirector *director = static_cast<SwigDirector_WrappedGeneratorServerDirector *>(obj);
  director->swig_connect_director(callback0, callback1, callback2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedServiceStubDirector(void * jarg1) {
  RobotRaconteur::WrappedServiceStubDirector *arg1 = (RobotRaconteur::WrappedServiceStubDirector *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedServiceStubDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStubDirector_DispatchEvent(void * jarg1, char * jarg2, void * jarg3) {
  RobotRaconteur::WrappedServiceStubDirector *arg1 = (RobotRaconteur::WrappedServiceStubDirector *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > arg3 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *argp3 ;
  
  arg1 = (RobotRaconteur::WrappedServiceStubDirector *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  argp3 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > >", 0);
    return ;
  }
  arg3 = *argp3; 
  
  try {
    (arg1)->DispatchEvent((std::string const &)*arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStubDirector_CallbackCall(void * jarg1, char * jarg2, void * jarg3) {
  void * jresult ;
  RobotRaconteur::WrappedServiceStubDirector *arg1 = (RobotRaconteur::WrappedServiceStubDirector *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > arg3 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *argp3 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > result;
  
  arg1 = (RobotRaconteur::WrappedServiceStubDirector *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  argp3 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > >", 0);
    return 0;
  }
  arg3 = *argp3; 
  
  try {
    result = (arg1)->CallbackCall((std::string const &)*arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedServiceStubDirector() {
  void * jresult ;
  RobotRaconteur::WrappedServiceStubDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedServiceStubDirector *)new SwigDirector_WrappedServiceStubDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStubDirector_director_connect(void *objarg, SwigDirector_WrappedServiceStubDirector::SWIG_Callback0_t callback0, SwigDirector_WrappedServiceStubDirector::SWIG_Callback1_t callback1) {
  RobotRaconteur::WrappedServiceStubDirector *obj = (RobotRaconteur::WrappedServiceStubDirector *)objarg;
  SwigDirector_WrappedServiceStubDirector *director = static_cast<SwigDirector_WrappedServiceStubDirector *>(obj);
  director->swig_connect_director(callback0, callback1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_AsyncStubReturnDirector(void * jarg1) {
  RobotRaconteur::AsyncStubReturnDirector *arg1 = (RobotRaconteur::AsyncStubReturnDirector *) 0 ;
  
  arg1 = (RobotRaconteur::AsyncStubReturnDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AsyncStubReturnDirector_handler(void * jarg1, void * jarg2, void * jarg3) {
  RobotRaconteur::AsyncStubReturnDirector *arg1 = (RobotRaconteur::AsyncStubReturnDirector *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *arg2 = 0 ;
  RobotRaconteur::HandlerErrorInfo *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > tempnull2 ;
  
  arg1 = (RobotRaconteur::AsyncStubReturnDirector *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *)jarg2 : &tempnull2; 
  arg3 = (RobotRaconteur::HandlerErrorInfo *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::HandlerErrorInfo & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->handler((boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &)*arg2,*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_AsyncStubReturnDirector() {
  void * jresult ;
  RobotRaconteur::AsyncStubReturnDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::AsyncStubReturnDirector *)new SwigDirector_AsyncStubReturnDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AsyncStubReturnDirector_director_connect(void *objarg, SwigDirector_AsyncStubReturnDirector::SWIG_Callback0_t callback0) {
  RobotRaconteur::AsyncStubReturnDirector *obj = (RobotRaconteur::AsyncStubReturnDirector *)objarg;
  SwigDirector_AsyncStubReturnDirector *director = static_cast<SwigDirector_AsyncStubReturnDirector *>(obj);
  director->swig_connect_director(callback0);
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedDirectorLock_valid(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::WrappedDirectorLock *arg1 = (RobotRaconteur::WrappedDirectorLock *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedDirectorLock > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedDirectorLock > *)jarg1;
  arg1 = (RobotRaconteur::WrappedDirectorLock *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->valid();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedDirectorLock(void * jarg1) {
  RobotRaconteur::WrappedDirectorLock *arg1 = (RobotRaconteur::WrappedDirectorLock *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedDirectorLock > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedDirectorLock > *)jarg1;
  arg1 = (RobotRaconteur::WrappedDirectorLock *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_PropertyGet(void * jarg1, char * jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (arg1)->PropertyGet((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_PropertySet(void * jarg1, char * jarg2, void * jarg3) {
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  std::string *arg2 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > tempnull3 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > temp3 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg3 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  // intrusive_ptr by reference
  if ( jarg3 ) {
    smartarg3 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg3;
    temp3 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg3->get(), true);
    arg3 = &temp3;
  } else {
    arg3 = &tempnull3;
  }
  
  
  try {
    (arg1)->PropertySet((std::string const &)*arg2,(boost::intrusive_ptr< RobotRaconteur::MessageElement > const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_FunctionCall(void * jarg1, char * jarg2, void * jarg3) {
  void * jresult ;
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (arg1)->FunctionCall((std::string const &)*arg2,(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_GeneratorFunctionCall(void * jarg1, char * jarg2, void * jarg3) {
  void * jresult ;
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedGeneratorClient > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (arg1)->GeneratorFunctionCall((std::string const &)*arg2,(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedGeneratorClient >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_async_PropertyGet(void * jarg1, char * jarg2, int jarg3, void * jarg4, int jarg5) {
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  std::string *arg2 = 0 ;
  int32_t arg3 ;
  RobotRaconteur::AsyncRequestDirector *arg4 = (RobotRaconteur::AsyncRequestDirector *) 0 ;
  int32_t arg5 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (int32_t)jarg3; 
  arg4 = (RobotRaconteur::AsyncRequestDirector *)jarg4; 
  arg5 = (int32_t)jarg5; 
  
  try {
    (arg1)->async_PropertyGet((std::string const &)*arg2,arg3,arg4,arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_async_PropertySet(void * jarg1, char * jarg2, void * jarg3, int jarg4, void * jarg5, int jarg6) {
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  std::string *arg2 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *arg3 = 0 ;
  int32_t arg4 ;
  RobotRaconteur::AsyncRequestDirector *arg5 = (RobotRaconteur::AsyncRequestDirector *) 0 ;
  int32_t arg6 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > tempnull3 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > temp3 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg3 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  // intrusive_ptr by reference
  if ( jarg3 ) {
    smartarg3 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg3;
    temp3 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg3->get(), true);
    arg3 = &temp3;
  } else {
    arg3 = &tempnull3;
  }
  
  arg4 = (int32_t)jarg4; 
  arg5 = (RobotRaconteur::AsyncRequestDirector *)jarg5; 
  arg6 = (int32_t)jarg6; 
  
  try {
    (arg1)->async_PropertySet((std::string const &)*arg2,(boost::intrusive_ptr< RobotRaconteur::MessageElement > const &)*arg3,arg4,arg5,arg6);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_async_FunctionCall(void * jarg1, char * jarg2, void * jarg3, int jarg4, void * jarg5, int jarg6) {
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg3 = 0 ;
  int32_t arg4 ;
  RobotRaconteur::AsyncRequestDirector *arg5 = (RobotRaconteur::AsyncRequestDirector *) 0 ;
  int32_t arg6 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > const & type is null", 0);
    return ;
  } 
  arg4 = (int32_t)jarg4; 
  arg5 = (RobotRaconteur::AsyncRequestDirector *)jarg5; 
  arg6 = (int32_t)jarg6; 
  
  try {
    (arg1)->async_FunctionCall((std::string const &)*arg2,(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > const &)*arg3,arg4,arg5,arg6);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_async_GeneratorFunctionCall(void * jarg1, char * jarg2, void * jarg3, int jarg4, void * jarg5, int jarg6) {
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg3 = 0 ;
  int32_t arg4 ;
  RobotRaconteur::AsyncGeneratorClientReturnDirector *arg5 = (RobotRaconteur::AsyncGeneratorClientReturnDirector *) 0 ;
  int32_t arg6 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > const & type is null", 0);
    return ;
  } 
  arg4 = (int32_t)jarg4; 
  arg5 = (RobotRaconteur::AsyncGeneratorClientReturnDirector *)jarg5; 
  arg6 = (int32_t)jarg6; 
  
  try {
    (arg1)->async_GeneratorFunctionCall((std::string const &)*arg2,(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > const &)*arg3,arg4,arg5,arg6);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_async_FindObjRef__SWIG_0(void * jarg1, char * jarg2, int jarg3, void * jarg4, int jarg5) {
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  std::string *arg2 = 0 ;
  int32_t arg3 ;
  RobotRaconteur::AsyncStubReturnDirector *arg4 = (RobotRaconteur::AsyncStubReturnDirector *) 0 ;
  int32_t arg5 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (int32_t)jarg3; 
  arg4 = (RobotRaconteur::AsyncStubReturnDirector *)jarg4; 
  arg5 = (int32_t)jarg5; 
  
  try {
    (arg1)->async_FindObjRef((std::string const &)*arg2,arg3,arg4,arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_async_FindObjRef__SWIG_1(void * jarg1, char * jarg2, char * jarg3, int jarg4, void * jarg5, int jarg6) {
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  int32_t arg4 ;
  RobotRaconteur::AsyncStubReturnDirector *arg5 = (RobotRaconteur::AsyncStubReturnDirector *) 0 ;
  int32_t arg6 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  arg4 = (int32_t)jarg4; 
  arg5 = (RobotRaconteur::AsyncStubReturnDirector *)jarg5; 
  arg6 = (int32_t)jarg6; 
  
  try {
    (arg1)->async_FindObjRef((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_async_FindObjRefTyped__SWIG_0(void * jarg1, char * jarg2, char * jarg3, int jarg4, void * jarg5, int jarg6) {
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  int32_t arg4 ;
  RobotRaconteur::AsyncStubReturnDirector *arg5 = (RobotRaconteur::AsyncStubReturnDirector *) 0 ;
  int32_t arg6 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  arg4 = (int32_t)jarg4; 
  arg5 = (RobotRaconteur::AsyncStubReturnDirector *)jarg5; 
  arg6 = (int32_t)jarg6; 
  
  try {
    (arg1)->async_FindObjRefTyped((std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_async_FindObjRefTyped__SWIG_1(void * jarg1, char * jarg2, char * jarg3, char * jarg4, int jarg5, void * jarg6, int jarg7) {
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  int32_t arg5 ;
  RobotRaconteur::AsyncStubReturnDirector *arg6 = (RobotRaconteur::AsyncStubReturnDirector *) 0 ;
  int32_t arg7 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  if (!jarg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg4_str(jarg4);
  arg4 = &arg4_str; 
  arg5 = (int32_t)jarg5; 
  arg6 = (RobotRaconteur::AsyncStubReturnDirector *)jarg6; 
  arg7 = (int32_t)jarg7; 
  
  try {
    (arg1)->async_FindObjRefTyped((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_GetPipe(void * jarg1, char * jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeClient > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (arg1)->GetPipe((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedPipeClient >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_GetWire(void * jarg1, char * jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireClient > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (arg1)->GetWire((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedWireClient >(result) : 0; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_GetObjectHeapID(void * jarg1) {
  int jresult ;
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  int result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (int)(arg1)->GetObjectHeapID();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_FindObjRef__SWIG_0(void * jarg1, char * jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = RobotRaconteur_WrappedServiceStub_FindObjRef__SWIG_0(arg1,(std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceStub >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_FindObjRef__SWIG_1(void * jarg1, char * jarg2, char * jarg3) {
  void * jresult ;
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  try {
    result = RobotRaconteur_WrappedServiceStub_FindObjRef__SWIG_1(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceStub >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_FindObjRefTyped__SWIG_0(void * jarg1, char * jarg2, char * jarg3) {
  void * jresult ;
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  try {
    result = RobotRaconteur_WrappedServiceStub_FindObjRefTyped__SWIG_0(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceStub >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_FindObjRefTyped__SWIG_1(void * jarg1, char * jarg2, char * jarg3, char * jarg4) {
  void * jresult ;
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  if (!jarg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg4_str(jarg4);
  arg4 = &arg4_str; 
  
  try {
    result = RobotRaconteur_WrappedServiceStub_FindObjRefTyped__SWIG_1(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceStub >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_GetArrayMemory(void * jarg1, char * jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ArrayMemoryBase > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (arg1)->GetArrayMemory((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::ArrayMemoryBase >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_GetMultiDimArrayMemory(void * jarg1, char * jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::MultiDimArrayMemoryBase > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (arg1)->GetMultiDimArrayMemory((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::MultiDimArrayMemoryBase >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_GetPodArrayMemory(void * jarg1, char * jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPodArrayMemoryClient > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (arg1)->GetPodArrayMemory((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedPodArrayMemoryClient >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_GetPodMultiDimArrayMemory(void * jarg1, char * jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPodMultiDimArrayMemoryClient > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (arg1)->GetPodMultiDimArrayMemory((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedPodMultiDimArrayMemoryClient >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_GetNamedArrayMemory(void * jarg1, char * jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedNamedArrayMemoryClient > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (arg1)->GetNamedArrayMemory((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedNamedArrayMemoryClient >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_GetNamedMultiDimArrayMemory(void * jarg1, char * jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (arg1)->GetNamedMultiDimArrayMemory((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedNamedMultiDimArrayMemoryClient >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_RRClose(void * jarg1) {
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->RRClose();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_RR_objecttype_set(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *)jarg2 : &tempnull2; 
  if (arg1) (arg1)->RR_objecttype = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_RR_objecttype_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  result = (boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *) & ((arg1)->RR_objecttype);
  jresult = *result ? new boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition >(*result) : 0; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_SetRRDirector(void * jarg1, void * jarg2, int jarg3) {
  unsigned int jresult ;
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  RobotRaconteur::WrappedServiceStubDirector *arg2 = (RobotRaconteur::WrappedServiceStubDirector *) 0 ;
  int32_t arg3 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::WrappedServiceStubDirector *)jarg2; 
  arg3 = (int32_t)jarg3; 
  
  try {
    result = (bool)(arg1)->SetRRDirector(arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_GetRRDirectorLock(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedDirectorLock > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetRRDirectorLock();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedDirectorLock >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_RRGetNode(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->RRGetNode();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::RobotRaconteurNode >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedServiceStub(void * jarg1) {
  RobotRaconteur::WrappedServiceStub *arg1 = (RobotRaconteur::WrappedServiceStub *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceStub > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceStub *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedServiceSkelDirector(void * jarg1) {
  RobotRaconteur::WrappedServiceSkelDirector *arg1 = (RobotRaconteur::WrappedServiceSkelDirector *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSkelDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkelDirector_Init(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedServiceSkelDirector *arg1 = (RobotRaconteur::WrappedServiceSkelDirector *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkel > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkel > tempnull2 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSkelDirector *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceSkel > *)jarg2 : &tempnull2; 
  
  try {
    (arg1)->Init((boost::shared_ptr< RobotRaconteur::WrappedServiceSkel > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkelDirector__CallGetProperty(void * jarg1, char * jarg2, void * jarg3) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSkelDirector *arg1 = (RobotRaconteur::WrappedServiceSkelDirector *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > tempnull3 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > result;
  
  arg1 = (RobotRaconteur::WrappedServiceSkelDirector *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > *)jarg3 : &tempnull3; 
  
  try {
    result = (arg1)->CallGetProperty((std::string const &)*arg2,(boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkelDirector__CallSetProperty(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
  RobotRaconteur::WrappedServiceSkelDirector *arg1 = (RobotRaconteur::WrappedServiceSkelDirector *) 0 ;
  std::string *arg2 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > arg3 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > *arg4 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg3 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > tempnull4 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSkelDirector *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  // intrusive_ptr by value
  smartarg3 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg3;
  if (smartarg3) {
    arg3 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg3->get(), true);
  }
  
  arg4 = jarg4 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > *)jarg4 : &tempnull4; 
  
  try {
    (arg1)->CallSetProperty((std::string const &)*arg2,arg3,(boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > const &)*arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkelDirector__CallFunction(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSkelDirector *arg1 = (RobotRaconteur::WrappedServiceSkelDirector *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > *arg4 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > tempnull4 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > result;
  
  arg1 = (RobotRaconteur::WrappedServiceSkelDirector *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > const & type is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > *)jarg4 : &tempnull4; 
  
  try {
    result = (arg1)->CallFunction((std::string const &)*arg2,(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > const &)*arg3,(boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > const &)*arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkelDirector__GetSubObj(void * jarg1, char * jarg2, char * jarg3) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSkelDirector *arg1 = (RobotRaconteur::WrappedServiceSkelDirector *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedRRObject > result;
  
  arg1 = (RobotRaconteur::WrappedServiceSkelDirector *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  try {
    result = (arg1)->GetSubObj((std::string const &)*arg2,(std::string const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedRRObject >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkelDirector__GetArrayMemory(void * jarg1, char * jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSkelDirector *arg1 = (RobotRaconteur::WrappedServiceSkelDirector *) 0 ;
  std::string *arg2 = 0 ;
  RobotRaconteur::WrappedArrayMemoryDirector *result = 0 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSkelDirector *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (RobotRaconteur::WrappedArrayMemoryDirector *)(arg1)->GetArrayMemory((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkelDirector__GetMultiDimArrayMemory(void * jarg1, char * jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSkelDirector *arg1 = (RobotRaconteur::WrappedServiceSkelDirector *) 0 ;
  std::string *arg2 = 0 ;
  RobotRaconteur::WrappedMultiDimArrayMemoryDirector *result = 0 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSkelDirector *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (RobotRaconteur::WrappedMultiDimArrayMemoryDirector *)(arg1)->GetMultiDimArrayMemory((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkelDirector__GetPodArrayMemory(void * jarg1, char * jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSkelDirector *arg1 = (RobotRaconteur::WrappedServiceSkelDirector *) 0 ;
  std::string *arg2 = 0 ;
  RobotRaconteur::WrappedPodArrayMemoryDirector *result = 0 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSkelDirector *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (RobotRaconteur::WrappedPodArrayMemoryDirector *)(arg1)->GetPodArrayMemory((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkelDirector__GetPodMultiDimArrayMemory(void * jarg1, char * jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSkelDirector *arg1 = (RobotRaconteur::WrappedServiceSkelDirector *) 0 ;
  std::string *arg2 = 0 ;
  RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector *result = 0 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSkelDirector *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (RobotRaconteur::WrappedPodMultiDimArrayMemoryDirector *)(arg1)->GetPodMultiDimArrayMemory((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkelDirector__GetNamedArrayMemory(void * jarg1, char * jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSkelDirector *arg1 = (RobotRaconteur::WrappedServiceSkelDirector *) 0 ;
  std::string *arg2 = 0 ;
  RobotRaconteur::WrappedNamedArrayMemoryDirector *result = 0 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSkelDirector *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (RobotRaconteur::WrappedNamedArrayMemoryDirector *)(arg1)->GetNamedArrayMemory((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkelDirector__GetNamedMultiDimArrayMemory(void * jarg1, char * jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSkelDirector *arg1 = (RobotRaconteur::WrappedServiceSkelDirector *) 0 ;
  std::string *arg2 = 0 ;
  RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector *result = 0 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSkelDirector *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (RobotRaconteur::WrappedNamedMultiDimArrayMemoryDirector *)(arg1)->GetNamedMultiDimArrayMemory((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkelDirector_MonitorEnter(void * jarg1, int jarg2) {
  RobotRaconteur::WrappedServiceSkelDirector *arg1 = (RobotRaconteur::WrappedServiceSkelDirector *) 0 ;
  int32_t arg2 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSkelDirector *)jarg1; 
  arg2 = (int32_t)jarg2; 
  
  try {
    (arg1)->MonitorEnter(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkelDirector_MonitorExit(void * jarg1) {
  RobotRaconteur::WrappedServiceSkelDirector *arg1 = (RobotRaconteur::WrappedServiceSkelDirector *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSkelDirector *)jarg1; 
  
  try {
    (arg1)->MonitorExit();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkelDirector_ReleaseCastObject(void * jarg1) {
  RobotRaconteur::WrappedServiceSkelDirector *arg1 = (RobotRaconteur::WrappedServiceSkelDirector *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSkelDirector *)jarg1; 
  
  try {
    (arg1)->ReleaseCastObject();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedServiceSkelDirector() {
  void * jresult ;
  RobotRaconteur::WrappedServiceSkelDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedServiceSkelDirector *)new SwigDirector_WrappedServiceSkelDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkelDirector_director_connect(void *objarg, SwigDirector_WrappedServiceSkelDirector::SWIG_Callback0_t callback0, SwigDirector_WrappedServiceSkelDirector::SWIG_Callback1_t callback1, SwigDirector_WrappedServiceSkelDirector::SWIG_Callback2_t callback2, SwigDirector_WrappedServiceSkelDirector::SWIG_Callback3_t callback3, SwigDirector_WrappedServiceSkelDirector::SWIG_Callback4_t callback4, SwigDirector_WrappedServiceSkelDirector::SWIG_Callback5_t callback5, SwigDirector_WrappedServiceSkelDirector::SWIG_Callback6_t callback6, SwigDirector_WrappedServiceSkelDirector::SWIG_Callback7_t callback7, SwigDirector_WrappedServiceSkelDirector::SWIG_Callback8_t callback8, SwigDirector_WrappedServiceSkelDirector::SWIG_Callback9_t callback9, SwigDirector_WrappedServiceSkelDirector::SWIG_Callback10_t callback10, SwigDirector_WrappedServiceSkelDirector::SWIG_Callback11_t callback11, SwigDirector_WrappedServiceSkelDirector::SWIG_Callback12_t callback12, SwigDirector_WrappedServiceSkelDirector::SWIG_Callback13_t callback13) {
  RobotRaconteur::WrappedServiceSkelDirector *obj = (RobotRaconteur::WrappedServiceSkelDirector *)objarg;
  SwigDirector_WrappedServiceSkelDirector *director = static_cast<SwigDirector_WrappedServiceSkelDirector *>(obj);
  director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7, callback8, callback9, callback10, callback11, callback12, callback13);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedRRObject(char * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  std::string *arg1 = 0 ;
  RobotRaconteur::WrappedServiceSkelDirector *arg2 = (RobotRaconteur::WrappedServiceSkelDirector *) 0 ;
  int32_t arg3 ;
  RobotRaconteur::WrappedRRObject *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (RobotRaconteur::WrappedServiceSkelDirector *)jarg2; 
  arg3 = (int32_t)jarg3; 
  
  try {
    result = (RobotRaconteur::WrappedRRObject *)new RobotRaconteur::WrappedRRObject((std::string const &)*arg1,arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::WrappedRRObject >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedRRObject_Type_set(void * jarg1, char * jarg2) {
  RobotRaconteur::WrappedRRObject *arg1 = (RobotRaconteur::WrappedRRObject *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedRRObject > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedRRObject > *)jarg1;
  arg1 = (RobotRaconteur::WrappedRRObject *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->Type = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_WrappedRRObject_Type_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::WrappedRRObject *arg1 = (RobotRaconteur::WrappedRRObject *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedRRObject > *smartarg1 = 0 ;
  std::string *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedRRObject > *)jarg1;
  arg1 = (RobotRaconteur::WrappedRRObject *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::string *) & ((arg1)->Type);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedRRObject(void * jarg1) {
  RobotRaconteur::WrappedRRObject *arg1 = (RobotRaconteur::WrappedRRObject *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedRRObject > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedRRObject > *)jarg1;
  arg1 = (RobotRaconteur::WrappedRRObject *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkel_Type_set(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedServiceSkel *arg1 = (RobotRaconteur::WrappedServiceSkel *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkel > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSkel > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSkel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *)jarg2 : &tempnull2; 
  if (arg1) (arg1)->Type = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkel_Type_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSkel *arg1 = (RobotRaconteur::WrappedServiceSkel *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkel > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSkel > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSkel *)(smartarg1 ? smartarg1->get() : 0); 
  result = (boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition > *) & ((arg1)->Type);
  jresult = *result ? new boost::shared_ptr< RobotRaconteur::ServiceEntryDefinition >(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkel_castobj_set(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedServiceSkel *arg1 = (RobotRaconteur::WrappedServiceSkel *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedRRObject > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkel > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedRRObject > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSkel > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSkel *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedRRObject > *)jarg2 : &tempnull2; 
  if (arg1) (arg1)->castobj = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkel_castobj_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSkel *arg1 = (RobotRaconteur::WrappedServiceSkel *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkel > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedRRObject > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSkel > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSkel *)(smartarg1 ? smartarg1->get() : 0); 
  result = (boost::shared_ptr< RobotRaconteur::WrappedRRObject > *) & ((arg1)->castobj);
  jresult = *result ? new boost::shared_ptr< RobotRaconteur::WrappedRRObject >(*result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkel_GetPipe(void * jarg1, char * jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSkel *arg1 = (RobotRaconteur::WrappedServiceSkel *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkel > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeServer > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSkel > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSkel *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (arg1)->GetPipe((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedPipeServer >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkel_GetWire(void * jarg1, char * jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSkel *arg1 = (RobotRaconteur::WrappedServiceSkel *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkel > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireServer > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSkel > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSkel *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (arg1)->GetWire((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedWireServer >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkel_WrappedDispatchEvent(void * jarg1, char * jarg2, void * jarg3) {
  RobotRaconteur::WrappedServiceSkel *arg1 = (RobotRaconteur::WrappedServiceSkel *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkel > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSkel > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSkel *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->WrappedDispatchEvent((std::string const &)*arg2,(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkel_WrappedCallbackCall(void * jarg1, char * jarg2, unsigned int jarg3, void * jarg4) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSkel *arg1 = (RobotRaconteur::WrappedServiceSkel *) 0 ;
  std::string *arg2 = 0 ;
  uint32_t arg3 ;
  std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *arg4 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkel > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSkel > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSkel *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (uint32_t)jarg3; 
  arg4 = (std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (arg1)->WrappedCallbackCall((std::string const &)*arg2,arg3,(std::vector< boost::intrusive_ptr< RobotRaconteur::MessageElement > > const &)*arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkel_RRGetNode(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSkel *arg1 = (RobotRaconteur::WrappedServiceSkel *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkel > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSkel > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSkel *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->RRGetNode();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::RobotRaconteurNode >(result) : 0; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkel_RegisterGeneratorServer(void * jarg1, char * jarg2, void * jarg3) {
  int jresult ;
  RobotRaconteur::WrappedServiceSkel *arg1 = (RobotRaconteur::WrappedServiceSkel *) 0 ;
  std::string *arg2 = 0 ;
  RobotRaconteur::WrappedGeneratorServerDirector *arg3 = (RobotRaconteur::WrappedGeneratorServerDirector *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkel > *smartarg1 = 0 ;
  int32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSkel > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSkel *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (RobotRaconteur::WrappedGeneratorServerDirector *)jarg3; 
  
  try {
    result = (int32_t)(arg1)->RegisterGeneratorServer((std::string const &)*arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkel_GetServicePath(void * jarg1) {
  char * jresult ;
  RobotRaconteur::WrappedServiceSkel *arg1 = (RobotRaconteur::WrappedServiceSkel *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkel > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSkel > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSkel *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetServicePath();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkel_GetContext(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSkel *arg1 = (RobotRaconteur::WrappedServiceSkel *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkel > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServerContext > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSkel > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSkel *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetContext();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::ServerContext >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedServiceSkel() {
  void * jresult ;
  RobotRaconteur::WrappedServiceSkel *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedServiceSkel *)new RobotRaconteur::WrappedServiceSkel();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::WrappedServiceSkel >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedServiceSkel(void * jarg1) {
  RobotRaconteur::WrappedServiceSkel *arg1 = (RobotRaconteur::WrappedServiceSkel *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkel > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSkel > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSkel *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServerServiceListenerDirector_objectheapid_set(void * jarg1, int jarg2) {
  ServerServiceListenerDirector *arg1 = (ServerServiceListenerDirector *) 0 ;
  int32_t arg2 ;
  
  arg1 = (ServerServiceListenerDirector *)jarg1; 
  arg2 = (int32_t)jarg2; 
  if (arg1) (arg1)->objectheapid = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_ServerServiceListenerDirector_objectheapid_get(void * jarg1) {
  int jresult ;
  ServerServiceListenerDirector *arg1 = (ServerServiceListenerDirector *) 0 ;
  int32_t result;
  
  arg1 = (ServerServiceListenerDirector *)jarg1; 
  result = (int32_t) ((arg1)->objectheapid);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_ServerServiceListenerDirector() {
  void * jresult ;
  ServerServiceListenerDirector *result = 0 ;
  
  
  try {
    result = (ServerServiceListenerDirector *)new SwigDirector_ServerServiceListenerDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServerServiceListenerDirector_Callback(void * jarg1, int jarg2, unsigned int jarg3) {
  ServerServiceListenerDirector *arg1 = (ServerServiceListenerDirector *) 0 ;
  int32_t arg2 ;
  uint32_t arg3 ;
  
  arg1 = (ServerServiceListenerDirector *)jarg1; 
  arg2 = (int32_t)jarg2; 
  arg3 = (uint32_t)jarg3; 
  
  try {
    (arg1)->Callback(arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServerServiceListenerDirector_CallbackSwigExplicitServerServiceListenerDirector(void * jarg1, int jarg2, unsigned int jarg3) {
  ServerServiceListenerDirector *arg1 = (ServerServiceListenerDirector *) 0 ;
  int32_t arg2 ;
  uint32_t arg3 ;
  
  arg1 = (ServerServiceListenerDirector *)jarg1; 
  arg2 = (int32_t)jarg2; 
  arg3 = (uint32_t)jarg3; 
  
  try {
    (arg1)->ServerServiceListenerDirector::Callback(arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_ServerServiceListenerDirector(void * jarg1) {
  ServerServiceListenerDirector *arg1 = (ServerServiceListenerDirector *) 0 ;
  
  arg1 = (ServerServiceListenerDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServerServiceListenerDirector_director_connect(void *objarg, SwigDirector_ServerServiceListenerDirector::SWIG_Callback0_t callback0) {
  ServerServiceListenerDirector *obj = (ServerServiceListenerDirector *)objarg;
  SwigDirector_ServerServiceListenerDirector *director = static_cast<SwigDirector_ServerServiceListenerDirector *>(obj);
  director->swig_connect_director(callback0);
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ServerContext_GetCurrentServicePath() {
  char * jresult ;
  std::string result;
  
  
  try {
    result = RobotRaconteur::ServerContext::GetCurrentServicePath();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServerContext__ReleaseServicePath__SWIG_0(void * jarg1, char * jarg2) {
  RobotRaconteur::ServerContext *arg1 = (RobotRaconteur::ServerContext *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServerContext > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServerContext > *)jarg1;
  arg1 = (RobotRaconteur::ServerContext *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->ReleaseServicePath((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServerContext__ReleaseServicePath__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
  RobotRaconteur::ServerContext *arg1 = (RobotRaconteur::ServerContext *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< uint32_t > arg3 ;
  boost::shared_ptr< RobotRaconteur::ServerContext > *smartarg1 = 0 ;
  std::vector< uint32_t > *argp3 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServerContext > *)jarg1;
  arg1 = (RobotRaconteur::ServerContext *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  argp3 = (std::vector< uint32_t > *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< uint32_t >", 0);
    return ;
  }
  arg3 = *argp3; 
  
  try {
    (arg1)->ReleaseServicePath((std::string const &)*arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServerContext_GetCurrentServerContext() {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::ServerContext > result;
  
  
  try {
    result = RobotRaconteur::ServerContext::GetCurrentServerContext();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::ServerContext >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServerContext_KickUser(void * jarg1, char * jarg2) {
  RobotRaconteur::ServerContext *arg1 = (RobotRaconteur::ServerContext *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServerContext > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServerContext > *)jarg1;
  arg1 = (RobotRaconteur::ServerContext *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->KickUser((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServerContext__AddServerServiceListener(void * jarg1, void * jarg2) {
  RobotRaconteur::ServerContext *arg1 = (RobotRaconteur::ServerContext *) 0 ;
  ServerServiceListenerDirector *arg2 = (ServerServiceListenerDirector *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServerContext > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServerContext > *)jarg1;
  arg1 = (RobotRaconteur::ServerContext *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (ServerServiceListenerDirector *)jarg2; 
  
  try {
    RobotRaconteur_ServerContext_AddServerServiceListener(arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServerContext__SetServiceAttributes(void * jarg1, void * jarg2) {
  RobotRaconteur::ServerContext *arg1 = (RobotRaconteur::ServerContext *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServerContext > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > temp2 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServerContext > *)jarg1;
  arg1 = (RobotRaconteur::ServerContext *)(smartarg1 ? smartarg1->get() : 0); 
  
  // intrusive_ptr by reference
  if ( jarg2 ) {
    smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg2;
    temp2 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg2->get(), true);
    arg2 = &temp2;
  } else {
    arg2 = &tempnull2;
  }
  
  
  try {
    RobotRaconteur_ServerContext_SetServiceAttributes(arg1,(boost::intrusive_ptr< RobotRaconteur::MessageElement > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServerContext_RequestObjectLock(void * jarg1, char * jarg2, char * jarg3) {
  RobotRaconteur::ServerContext *arg1 = (RobotRaconteur::ServerContext *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServerContext > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServerContext > *)jarg1;
  arg1 = (RobotRaconteur::ServerContext *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  try {
    (arg1)->RequestObjectLock((std::string const &)*arg2,(std::string const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServerContext_RequestClientObjectLock(void * jarg1, char * jarg2, char * jarg3, unsigned int jarg4) {
  RobotRaconteur::ServerContext *arg1 = (RobotRaconteur::ServerContext *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  uint32_t arg4 ;
  boost::shared_ptr< RobotRaconteur::ServerContext > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServerContext > *)jarg1;
  arg1 = (RobotRaconteur::ServerContext *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  arg4 = (uint32_t)jarg4; 
  
  try {
    (arg1)->RequestClientObjectLock((std::string const &)*arg2,(std::string const &)*arg3,arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServerContext_ReleaseObjectLock(void * jarg1, char * jarg2, char * jarg3, unsigned int jarg4) {
  RobotRaconteur::ServerContext *arg1 = (RobotRaconteur::ServerContext *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  bool arg4 ;
  boost::shared_ptr< RobotRaconteur::ServerContext > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServerContext > *)jarg1;
  arg1 = (RobotRaconteur::ServerContext *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  arg4 = jarg4 ? true : false; 
  
  try {
    (arg1)->ReleaseObjectLock((std::string const &)*arg2,(std::string const &)*arg3,arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ServerContext_GetObjectLockUsername(void * jarg1, char * jarg2) {
  char * jresult ;
  RobotRaconteur::ServerContext *arg1 = (RobotRaconteur::ServerContext *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServerContext > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServerContext > *)jarg1;
  arg1 = (RobotRaconteur::ServerContext *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (arg1)->GetObjectLockUsername((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServerContext_GetNode(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ServerContext *arg1 = (RobotRaconteur::ServerContext *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServerContext > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServerContext > *)jarg1;
  arg1 = (RobotRaconteur::ServerContext *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetNode();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::RobotRaconteurNode >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServerContext_GetExtraImports(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ServerContext *arg1 = (RobotRaconteur::ServerContext *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServerContext > *smartarg1 = 0 ;
  std::vector< std::string > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServerContext > *)jarg1;
  arg1 = (RobotRaconteur::ServerContext *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetExtraImports();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< std::string >((const std::vector< std::string > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServerContext_AddExtraImport(void * jarg1, char * jarg2) {
  RobotRaconteur::ServerContext *arg1 = (RobotRaconteur::ServerContext *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServerContext > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServerContext > *)jarg1;
  arg1 = (RobotRaconteur::ServerContext *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->AddExtraImport((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_ServerContext_RemoveExtraImport(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::ServerContext *arg1 = (RobotRaconteur::ServerContext *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServerContext > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServerContext > *)jarg1;
  arg1 = (RobotRaconteur::ServerContext *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (bool)(arg1)->RemoveExtraImport((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServerContext_GetCandidateConnectionURLs(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ServerContext *arg1 = (RobotRaconteur::ServerContext *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServerContext > *smartarg1 = 0 ;
  std::vector< std::string > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServerContext > *)jarg1;
  arg1 = (RobotRaconteur::ServerContext *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetCandidateConnectionURLs();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< std::string >((const std::vector< std::string > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServerContext_PrintCandidateConnectionURLs(void * jarg1) {
  RobotRaconteur::ServerContext *arg1 = (RobotRaconteur::ServerContext *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServerContext > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServerContext > *)jarg1;
  arg1 = (RobotRaconteur::ServerContext *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->PrintCandidateConnectionURLs();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServerContext_LogCandidateConnectionURLs__SWIG_0(void * jarg1, int jarg2) {
  RobotRaconteur::ServerContext *arg1 = (RobotRaconteur::ServerContext *) 0 ;
  RobotRaconteur::RobotRaconteur_LogLevel arg2 ;
  boost::shared_ptr< RobotRaconteur::ServerContext > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServerContext > *)jarg1;
  arg1 = (RobotRaconteur::ServerContext *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::RobotRaconteur_LogLevel)jarg2; 
  
  try {
    (arg1)->LogCandidateConnectionURLs(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServerContext_LogCandidateConnectionURLs__SWIG_1(void * jarg1) {
  RobotRaconteur::ServerContext *arg1 = (RobotRaconteur::ServerContext *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServerContext > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServerContext > *)jarg1;
  arg1 = (RobotRaconteur::ServerContext *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->LogCandidateConnectionURLs();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_ServerContext(void * jarg1) {
  RobotRaconteur::ServerContext *arg1 = (RobotRaconteur::ServerContext *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServerContext > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServerContext > *)jarg1;
  arg1 = (RobotRaconteur::ServerContext *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_AuthenticatedUser__GetUsername(void * jarg1) {
  char * jresult ;
  RobotRaconteur::AuthenticatedUser *arg1 = (RobotRaconteur::AuthenticatedUser *) 0 ;
  boost::shared_ptr< RobotRaconteur::AuthenticatedUser > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::AuthenticatedUser > *)jarg1;
  arg1 = (RobotRaconteur::AuthenticatedUser *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetUsername();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_AuthenticatedUser__GetPrivileges(void * jarg1) {
  void * jresult ;
  RobotRaconteur::AuthenticatedUser *arg1 = (RobotRaconteur::AuthenticatedUser *) 0 ;
  boost::shared_ptr< RobotRaconteur::AuthenticatedUser > *smartarg1 = 0 ;
  std::vector< std::string > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::AuthenticatedUser > *)jarg1;
  arg1 = (RobotRaconteur::AuthenticatedUser *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetPrivileges();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< std::string >((const std::vector< std::string > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_AuthenticatedUser__GetProperties(void * jarg1) {
  void * jresult ;
  RobotRaconteur::AuthenticatedUser *arg1 = (RobotRaconteur::AuthenticatedUser *) 0 ;
  boost::shared_ptr< RobotRaconteur::AuthenticatedUser > *smartarg1 = 0 ;
  std::vector< std::string > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::AuthenticatedUser > *)jarg1;
  arg1 = (RobotRaconteur::AuthenticatedUser *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetProperties();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< std::string >((const std::vector< std::string > &)result); 
  return jresult;
}


SWIGEXPORT int64_t SWIGSTDCALL CSharp_RobotRaconteur_AuthenticatedUser__GetLoginTime(void * jarg1) {
  int64_t jresult ;
  RobotRaconteur::AuthenticatedUser *arg1 = (RobotRaconteur::AuthenticatedUser *) 0 ;
  boost::shared_ptr< RobotRaconteur::AuthenticatedUser > *smartarg1 = 0 ;
  boost::posix_time::ptime result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::AuthenticatedUser > *)jarg1;
  arg1 = (RobotRaconteur::AuthenticatedUser *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetLoginTime();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  {
    {
      boost::posix_time::time_duration ptime_diff = (result - boost::posix_time::ptime(boost::gregorian::date(1970,1,1),boost::posix_time::time_duration(0,0,0)));
      jresult=ptime_diff.total_microseconds()*10;
    }
  }
  return jresult;
}


SWIGEXPORT int64_t SWIGSTDCALL CSharp_RobotRaconteur_AuthenticatedUser__GetLastAccessTime(void * jarg1) {
  int64_t jresult ;
  RobotRaconteur::AuthenticatedUser *arg1 = (RobotRaconteur::AuthenticatedUser *) 0 ;
  boost::shared_ptr< RobotRaconteur::AuthenticatedUser > *smartarg1 = 0 ;
  boost::posix_time::ptime result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::AuthenticatedUser > *)jarg1;
  arg1 = (RobotRaconteur::AuthenticatedUser *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetLastAccessTime();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  {
    {
      boost::posix_time::time_duration ptime_diff = (result - boost::posix_time::ptime(boost::gregorian::date(1970,1,1),boost::posix_time::time_duration(0,0,0)));
      jresult=ptime_diff.total_microseconds()*10;
    }
  }
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_AuthenticatedUser(void * jarg1) {
  RobotRaconteur::AuthenticatedUser *arg1 = (RobotRaconteur::AuthenticatedUser *) 0 ;
  boost::shared_ptr< RobotRaconteur::AuthenticatedUser > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::AuthenticatedUser > *)jarg1;
  arg1 = (RobotRaconteur::AuthenticatedUser *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_ServerEndpoint_GetCurrentEndpoint() {
  unsigned int jresult ;
  uint32_t result;
  
  
  try {
    result = (uint32_t)RobotRaconteur_ServerEndpoint_GetCurrentEndpoint();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServerEndpoint_GetCurrentAuthenticatedUser() {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::AuthenticatedUser > result;
  
  
  try {
    result = RobotRaconteur::ServerEndpoint::GetCurrentAuthenticatedUser();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::AuthenticatedUser >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_ServerEndpoint(void * jarg1) {
  RobotRaconteur::ServerEndpoint *arg1 = (RobotRaconteur::ServerEndpoint *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServerEndpoint > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServerEndpoint > *)jarg1;
  arg1 = (RobotRaconteur::ServerEndpoint *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkelAsyncAdapter_MakeAsync(void * jarg1) {
  RobotRaconteur::WrappedServiceSkelAsyncAdapter *arg1 = (RobotRaconteur::WrappedServiceSkelAsyncAdapter *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSkelAsyncAdapter > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSkelAsyncAdapter *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->MakeAsync();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkelAsyncAdapter_IsAsync(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::WrappedServiceSkelAsyncAdapter *arg1 = (RobotRaconteur::WrappedServiceSkelAsyncAdapter *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSkelAsyncAdapter > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSkelAsyncAdapter *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->IsAsync();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkelAsyncAdapter_End__SWIG_0(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedServiceSkelAsyncAdapter *arg1 = (RobotRaconteur::WrappedServiceSkelAsyncAdapter *) 0 ;
  RobotRaconteur::HandlerErrorInfo *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSkelAsyncAdapter > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSkelAsyncAdapter *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::HandlerErrorInfo *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::HandlerErrorInfo const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->End((RobotRaconteur::HandlerErrorInfo const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSkelAsyncAdapter_End__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
  RobotRaconteur::WrappedServiceSkelAsyncAdapter *arg1 = (RobotRaconteur::WrappedServiceSkelAsyncAdapter *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *arg2 = 0 ;
  RobotRaconteur::HandlerErrorInfo *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > temp2 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSkelAsyncAdapter > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSkelAsyncAdapter *)(smartarg1 ? smartarg1->get() : 0); 
  
  // intrusive_ptr by reference
  if ( jarg2 ) {
    smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg2;
    temp2 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg2->get(), true);
    arg2 = &temp2;
  } else {
    arg2 = &tempnull2;
  }
  
  arg3 = (RobotRaconteur::HandlerErrorInfo *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::HandlerErrorInfo const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->End((boost::intrusive_ptr< RobotRaconteur::MessageElement > const &)*arg2,(RobotRaconteur::HandlerErrorInfo const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedServiceSkelAsyncAdapter(void * jarg1) {
  RobotRaconteur::WrappedServiceSkelAsyncAdapter *arg1 = (RobotRaconteur::WrappedServiceSkelAsyncAdapter *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSkelAsyncAdapter > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSkelAsyncAdapter > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSkelAsyncAdapter *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_NativeUserAuthenticator__AuthenticateUser(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  RobotRaconteur::UserAuthenticator *arg1 = (RobotRaconteur::UserAuthenticator *) 0 ;
  std::string *arg2 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServerContext > *arg4 = 0 ;
  boost::shared_ptr< RobotRaconteur::UserAuthenticator > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > tempnull3 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > temp3 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg3 ;
  boost::shared_ptr< RobotRaconteur::ServerContext > tempnull4 ;
  boost::shared_ptr< RobotRaconteur::AuthenticatedUser > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::UserAuthenticator > *)jarg1;
  arg1 = (RobotRaconteur::UserAuthenticator *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  // intrusive_ptr by reference
  if ( jarg3 ) {
    smartarg3 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg3;
    temp3 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg3->get(), true);
    arg3 = &temp3;
  } else {
    arg3 = &tempnull3;
  }
  
  arg4 = jarg4 ? (boost::shared_ptr< RobotRaconteur::ServerContext > *)jarg4 : &tempnull4; 
  
  try {
    result = RobotRaconteur_UserAuthenticator_AuthenticateUser(arg1,(std::string const &)*arg2,(boost::intrusive_ptr< RobotRaconteur::MessageElement > const &)*arg3,(boost::shared_ptr< RobotRaconteur::ServerContext > const &)*arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::AuthenticatedUser >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_NativeUserAuthenticator(void * jarg1) {
  RobotRaconteur::UserAuthenticator *arg1 = (RobotRaconteur::UserAuthenticator *) 0 ;
  boost::shared_ptr< RobotRaconteur::UserAuthenticator > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::UserAuthenticator > *)jarg1;
  arg1 = (RobotRaconteur::UserAuthenticator *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_ServiceSecurityPolicy(void * jarg1, void * jarg2) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::UserAuthenticator > *arg1 = 0 ;
  std::map< std::string,std::string,std::less< std::string > > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::UserAuthenticator > tempnull1 ;
  RobotRaconteur::ServiceSecurityPolicy *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::UserAuthenticator > *)jarg1 : &tempnull1; 
  arg2 = (std::map< std::string,std::string,std::less< std::string > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< std::string,std::string,std::less< std::string > > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (RobotRaconteur::ServiceSecurityPolicy *)new RobotRaconteur::ServiceSecurityPolicy((boost::shared_ptr< RobotRaconteur::UserAuthenticator > const &)*arg1,(std::map< std::string,std::string,std::less< std::string > > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::ServiceSecurityPolicy >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_ServiceSecurityPolicy(void * jarg1) {
  RobotRaconteur::ServiceSecurityPolicy *arg1 = (RobotRaconteur::ServiceSecurityPolicy *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceSecurityPolicy > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::ServiceSecurityPolicy > *)jarg1;
  arg1 = (RobotRaconteur::ServiceSecurityPolicy *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_PasswordFileUserAuthenticator__SWIG_0(char * jarg1, unsigned int jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  bool arg2 ;
  RobotRaconteur::PasswordFileUserAuthenticator *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = jarg2 ? true : false; 
  
  try {
    result = (RobotRaconteur::PasswordFileUserAuthenticator *)new RobotRaconteur::PasswordFileUserAuthenticator((std::string const &)*arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::PasswordFileUserAuthenticator >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_PasswordFileUserAuthenticator__SWIG_1(char * jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  RobotRaconteur::PasswordFileUserAuthenticator *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  
  try {
    result = (RobotRaconteur::PasswordFileUserAuthenticator *)new RobotRaconteur::PasswordFileUserAuthenticator((std::string const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::PasswordFileUserAuthenticator >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_PasswordFileUserAuthenticator(void * jarg1) {
  RobotRaconteur::PasswordFileUserAuthenticator *arg1 = (RobotRaconteur::PasswordFileUserAuthenticator *) 0 ;
  boost::shared_ptr< RobotRaconteur::PasswordFileUserAuthenticator > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::PasswordFileUserAuthenticator > *)jarg1;
  arg1 = (RobotRaconteur::PasswordFileUserAuthenticator *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedUserAuthenticatorDirector(void * jarg1) {
  RobotRaconteur::WrappedUserAuthenticatorDirector *arg1 = (RobotRaconteur::WrappedUserAuthenticatorDirector *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedUserAuthenticatorDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedUserAuthenticatorDirector_AuthenticateUser(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  RobotRaconteur::WrappedUserAuthenticatorDirector *arg1 = (RobotRaconteur::WrappedUserAuthenticatorDirector *) 0 ;
  std::string *arg2 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > arg3 ;
  boost::shared_ptr< RobotRaconteur::ServerContext > *arg4 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg3 ;
  boost::shared_ptr< RobotRaconteur::ServerContext > tempnull4 ;
  boost::shared_ptr< RobotRaconteur::AuthenticatedUser > result;
  
  arg1 = (RobotRaconteur::WrappedUserAuthenticatorDirector *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  // intrusive_ptr by value
  smartarg3 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg3;
  if (smartarg3) {
    arg3 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg3->get(), true);
  }
  
  arg4 = jarg4 ? (boost::shared_ptr< RobotRaconteur::ServerContext > *)jarg4 : &tempnull4; 
  
  try {
    result = (arg1)->AuthenticateUser((std::string const &)*arg2,arg3,(boost::shared_ptr< RobotRaconteur::ServerContext > const &)*arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::AuthenticatedUser >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedUserAuthenticatorDirector() {
  void * jresult ;
  RobotRaconteur::WrappedUserAuthenticatorDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedUserAuthenticatorDirector *)new SwigDirector_WrappedUserAuthenticatorDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedUserAuthenticatorDirector_director_connect(void *objarg, SwigDirector_WrappedUserAuthenticatorDirector::SWIG_Callback0_t callback0) {
  RobotRaconteur::WrappedUserAuthenticatorDirector *obj = (RobotRaconteur::WrappedUserAuthenticatorDirector *)objarg;
  SwigDirector_WrappedUserAuthenticatorDirector *director = static_cast<SwigDirector_WrappedUserAuthenticatorDirector *>(obj);
  director->swig_connect_director(callback0);
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedUserAuthenticator_SetRRDirector(void * jarg1, void * jarg2, int jarg3) {
  RobotRaconteur::WrappedUserAuthenticator *arg1 = (RobotRaconteur::WrappedUserAuthenticator *) 0 ;
  RobotRaconteur::WrappedUserAuthenticatorDirector *arg2 = (RobotRaconteur::WrappedUserAuthenticatorDirector *) 0 ;
  int arg3 ;
  boost::shared_ptr< RobotRaconteur::WrappedUserAuthenticator > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedUserAuthenticator > *)jarg1;
  arg1 = (RobotRaconteur::WrappedUserAuthenticator *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::WrappedUserAuthenticatorDirector *)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    (arg1)->SetRRDirector(arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedUserAuthenticator() {
  void * jresult ;
  RobotRaconteur::WrappedUserAuthenticator *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedUserAuthenticator *)new RobotRaconteur::WrappedUserAuthenticator();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::WrappedUserAuthenticator >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedUserAuthenticator(void * jarg1) {
  RobotRaconteur::WrappedUserAuthenticator *arg1 = (RobotRaconteur::WrappedUserAuthenticator *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedUserAuthenticator > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedUserAuthenticator > *)jarg1;
  arg1 = (RobotRaconteur::WrappedUserAuthenticator *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_AsyncServiceInfo2VectorReturnDirector(void * jarg1) {
  RobotRaconteur::AsyncServiceInfo2VectorReturnDirector *arg1 = (RobotRaconteur::AsyncServiceInfo2VectorReturnDirector *) 0 ;
  
  arg1 = (RobotRaconteur::AsyncServiceInfo2VectorReturnDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AsyncServiceInfo2VectorReturnDirector_handler(void * jarg1, void * jarg2) {
  RobotRaconteur::AsyncServiceInfo2VectorReturnDirector *arg1 = (RobotRaconteur::AsyncServiceInfo2VectorReturnDirector *) 0 ;
  std::vector< RobotRaconteur::ServiceInfo2Wrapped > *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::AsyncServiceInfo2VectorReturnDirector *)jarg1; 
  arg2 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::ServiceInfo2Wrapped > const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->handler((std::vector< RobotRaconteur::ServiceInfo2Wrapped > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_AsyncServiceInfo2VectorReturnDirector() {
  void * jresult ;
  RobotRaconteur::AsyncServiceInfo2VectorReturnDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::AsyncServiceInfo2VectorReturnDirector *)new SwigDirector_AsyncServiceInfo2VectorReturnDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AsyncServiceInfo2VectorReturnDirector_director_connect(void *objarg, SwigDirector_AsyncServiceInfo2VectorReturnDirector::SWIG_Callback0_t callback0) {
  RobotRaconteur::AsyncServiceInfo2VectorReturnDirector *obj = (RobotRaconteur::AsyncServiceInfo2VectorReturnDirector *)objarg;
  SwigDirector_AsyncServiceInfo2VectorReturnDirector *director = static_cast<SwigDirector_AsyncServiceInfo2VectorReturnDirector *>(obj);
  director->swig_connect_director(callback0);
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_AsyncNodeInfo2VectorReturnDirector(void * jarg1) {
  RobotRaconteur::AsyncNodeInfo2VectorReturnDirector *arg1 = (RobotRaconteur::AsyncNodeInfo2VectorReturnDirector *) 0 ;
  
  arg1 = (RobotRaconteur::AsyncNodeInfo2VectorReturnDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AsyncNodeInfo2VectorReturnDirector_handler(void * jarg1, void * jarg2) {
  RobotRaconteur::AsyncNodeInfo2VectorReturnDirector *arg1 = (RobotRaconteur::AsyncNodeInfo2VectorReturnDirector *) 0 ;
  std::vector< RobotRaconteur::NodeInfo2 > *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::AsyncNodeInfo2VectorReturnDirector *)jarg1; 
  arg2 = (std::vector< RobotRaconteur::NodeInfo2 > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::NodeInfo2 > const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->handler((std::vector< RobotRaconteur::NodeInfo2 > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_AsyncNodeInfo2VectorReturnDirector() {
  void * jresult ;
  RobotRaconteur::AsyncNodeInfo2VectorReturnDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::AsyncNodeInfo2VectorReturnDirector *)new SwigDirector_AsyncNodeInfo2VectorReturnDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AsyncNodeInfo2VectorReturnDirector_director_connect(void *objarg, SwigDirector_AsyncNodeInfo2VectorReturnDirector::SWIG_Callback0_t callback0) {
  RobotRaconteur::AsyncNodeInfo2VectorReturnDirector *obj = (RobotRaconteur::AsyncNodeInfo2VectorReturnDirector *)objarg;
  SwigDirector_AsyncNodeInfo2VectorReturnDirector *director = static_cast<SwigDirector_AsyncNodeInfo2VectorReturnDirector *>(obj);
  director->swig_connect_director(callback0);
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceInfo2Wrapped_Name_set(void * jarg1, char * jarg2) {
  RobotRaconteur::ServiceInfo2Wrapped *arg1 = (RobotRaconteur::ServiceInfo2Wrapped *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::ServiceInfo2Wrapped *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->Name = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ServiceInfo2Wrapped_Name_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::ServiceInfo2Wrapped *arg1 = (RobotRaconteur::ServiceInfo2Wrapped *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (RobotRaconteur::ServiceInfo2Wrapped *)jarg1; 
  result = (std::string *) & ((arg1)->Name);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceInfo2Wrapped_RootObjectType_set(void * jarg1, char * jarg2) {
  RobotRaconteur::ServiceInfo2Wrapped *arg1 = (RobotRaconteur::ServiceInfo2Wrapped *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::ServiceInfo2Wrapped *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->RootObjectType = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ServiceInfo2Wrapped_RootObjectType_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::ServiceInfo2Wrapped *arg1 = (RobotRaconteur::ServiceInfo2Wrapped *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (RobotRaconteur::ServiceInfo2Wrapped *)jarg1; 
  result = (std::string *) & ((arg1)->RootObjectType);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceInfo2Wrapped_RootObjectImplements_set(void * jarg1, void * jarg2) {
  RobotRaconteur::ServiceInfo2Wrapped *arg1 = (RobotRaconteur::ServiceInfo2Wrapped *) 0 ;
  std::vector< std::string > *arg2 = (std::vector< std::string > *) 0 ;
  
  arg1 = (RobotRaconteur::ServiceInfo2Wrapped *)jarg1; 
  arg2 = (std::vector< std::string > *)jarg2; 
  if (arg1) (arg1)->RootObjectImplements = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServiceInfo2Wrapped_RootObjectImplements_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ServiceInfo2Wrapped *arg1 = (RobotRaconteur::ServiceInfo2Wrapped *) 0 ;
  std::vector< std::string > *result = 0 ;
  
  arg1 = (RobotRaconteur::ServiceInfo2Wrapped *)jarg1; 
  result = (std::vector< std::string > *)& ((arg1)->RootObjectImplements);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceInfo2Wrapped_ConnectionURL_set(void * jarg1, void * jarg2) {
  RobotRaconteur::ServiceInfo2Wrapped *arg1 = (RobotRaconteur::ServiceInfo2Wrapped *) 0 ;
  std::vector< std::string > *arg2 = (std::vector< std::string > *) 0 ;
  
  arg1 = (RobotRaconteur::ServiceInfo2Wrapped *)jarg1; 
  arg2 = (std::vector< std::string > *)jarg2; 
  if (arg1) (arg1)->ConnectionURL = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServiceInfo2Wrapped_ConnectionURL_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ServiceInfo2Wrapped *arg1 = (RobotRaconteur::ServiceInfo2Wrapped *) 0 ;
  std::vector< std::string > *result = 0 ;
  
  arg1 = (RobotRaconteur::ServiceInfo2Wrapped *)jarg1; 
  result = (std::vector< std::string > *)& ((arg1)->ConnectionURL);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceInfo2Wrapped_Attributes_set(void * jarg1, void * jarg2) {
  RobotRaconteur::ServiceInfo2Wrapped *arg1 = (RobotRaconteur::ServiceInfo2Wrapped *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *arg2 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > temp2 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg2 ;
  
  arg1 = (RobotRaconteur::ServiceInfo2Wrapped *)jarg1; 
  
  // intrusive_ptr by reference
  if ( jarg2 ) {
    smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg2;
    temp2 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg2->get(), true);
    arg2 = &temp2;
  } else {
    arg2 = &tempnull2;
  }
  
  if (arg1) (arg1)->Attributes = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServiceInfo2Wrapped_Attributes_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ServiceInfo2Wrapped *arg1 = (RobotRaconteur::ServiceInfo2Wrapped *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *result = 0 ;
  
  arg1 = (RobotRaconteur::ServiceInfo2Wrapped *)jarg1; 
  result = (boost::intrusive_ptr< RobotRaconteur::MessageElement > *) & ((arg1)->Attributes);
  
  if (*result) {
    intrusive_ptr_add_ref(result->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >(result->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceInfo2Wrapped_NodeID_set(void * jarg1, void * jarg2) {
  RobotRaconteur::ServiceInfo2Wrapped *arg1 = (RobotRaconteur::ServiceInfo2Wrapped *) 0 ;
  RobotRaconteur::NodeID *arg2 = (RobotRaconteur::NodeID *) 0 ;
  
  arg1 = (RobotRaconteur::ServiceInfo2Wrapped *)jarg1; 
  arg2 = (RobotRaconteur::NodeID *)jarg2; 
  if (arg1) (arg1)->NodeID = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServiceInfo2Wrapped_NodeID_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ServiceInfo2Wrapped *arg1 = (RobotRaconteur::ServiceInfo2Wrapped *) 0 ;
  RobotRaconteur::NodeID *result = 0 ;
  
  arg1 = (RobotRaconteur::ServiceInfo2Wrapped *)jarg1; 
  result = (RobotRaconteur::NodeID *)& ((arg1)->NodeID);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceInfo2Wrapped_NodeName_set(void * jarg1, char * jarg2) {
  RobotRaconteur::ServiceInfo2Wrapped *arg1 = (RobotRaconteur::ServiceInfo2Wrapped *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::ServiceInfo2Wrapped *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->NodeName = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ServiceInfo2Wrapped_NodeName_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::ServiceInfo2Wrapped *arg1 = (RobotRaconteur::ServiceInfo2Wrapped *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (RobotRaconteur::ServiceInfo2Wrapped *)jarg1; 
  result = (std::string *) & ((arg1)->NodeName);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_ServiceInfo2Wrapped() {
  void * jresult ;
  RobotRaconteur::ServiceInfo2Wrapped *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::ServiceInfo2Wrapped *)new RobotRaconteur::ServiceInfo2Wrapped();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_ServiceInfo2Wrapped(void * jarg1) {
  RobotRaconteur::ServiceInfo2Wrapped *arg1 = (RobotRaconteur::ServiceInfo2Wrapped *) 0 ;
  
  arg1 = (RobotRaconteur::ServiceInfo2Wrapped *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedFindServiceByType(void * jarg1, char * jarg2, void * jarg3) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string > *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  std::vector< RobotRaconteur::ServiceInfo2Wrapped > result;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (std::vector< std::string > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = RobotRaconteur::WrappedFindServiceByType((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1,(std::string const &)*arg2,(std::vector< std::string > const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< RobotRaconteur::ServiceInfo2Wrapped >((const std::vector< RobotRaconteur::ServiceInfo2Wrapped > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AsyncWrappedFindServiceByType(void * jarg1, char * jarg2, void * jarg3, int jarg4, void * jarg5, int jarg6) {
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string > *arg3 = 0 ;
  int32_t arg4 ;
  RobotRaconteur::AsyncServiceInfo2VectorReturnDirector *arg5 = (RobotRaconteur::AsyncServiceInfo2VectorReturnDirector *) 0 ;
  int32_t arg6 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (std::vector< std::string > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return ;
  } 
  arg4 = (int32_t)jarg4; 
  arg5 = (RobotRaconteur::AsyncServiceInfo2VectorReturnDirector *)jarg5; 
  arg6 = (int32_t)jarg6; 
  
  try {
    RobotRaconteur::AsyncWrappedFindServiceByType((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1,(std::string const &)*arg2,(std::vector< std::string > const &)*arg3,arg4,arg5,arg6);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorserviceinfo2wrapped_Clear(void * jarg1) {
  std::vector< RobotRaconteur::ServiceInfo2Wrapped > *arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *) 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *)jarg1; 
  
  try {
    (arg1)->clear();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorserviceinfo2wrapped_Add(void * jarg1, void * jarg2) {
  std::vector< RobotRaconteur::ServiceInfo2Wrapped > *arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *) 0 ;
  RobotRaconteur::ServiceInfo2Wrapped *arg2 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *)jarg1; 
  arg2 = (RobotRaconteur::ServiceInfo2Wrapped *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::ServiceInfo2Wrapped const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->push_back((RobotRaconteur::ServiceInfo2Wrapped const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectorserviceinfo2wrapped_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< RobotRaconteur::ServiceInfo2Wrapped > *arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *) 0 ;
  std::vector< RobotRaconteur::ServiceInfo2Wrapped >::size_type result;
  
  arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *)jarg1; 
  
  try {
    result = ((std::vector< RobotRaconteur::ServiceInfo2Wrapped > const *)arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectorserviceinfo2wrapped_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< RobotRaconteur::ServiceInfo2Wrapped > *arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *) 0 ;
  std::vector< RobotRaconteur::ServiceInfo2Wrapped >::size_type result;
  
  arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *)jarg1; 
  
  try {
    result = ((std::vector< RobotRaconteur::ServiceInfo2Wrapped > const *)arg1)->capacity();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorserviceinfo2wrapped_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< RobotRaconteur::ServiceInfo2Wrapped > *arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *) 0 ;
  std::vector< RobotRaconteur::ServiceInfo2Wrapped >::size_type arg2 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *)jarg1; 
  arg2 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped >::size_type)jarg2; 
  
  try {
    (arg1)->reserve(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorserviceinfo2wrapped__SWIG_0() {
  void * jresult ;
  std::vector< RobotRaconteur::ServiceInfo2Wrapped > *result = 0 ;
  
  
  try {
    result = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *)new std::vector< RobotRaconteur::ServiceInfo2Wrapped >();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorserviceinfo2wrapped__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< RobotRaconteur::ServiceInfo2Wrapped > *arg1 = 0 ;
  std::vector< RobotRaconteur::ServiceInfo2Wrapped > *result = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::ServiceInfo2Wrapped > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *)new std::vector< RobotRaconteur::ServiceInfo2Wrapped >((std::vector< RobotRaconteur::ServiceInfo2Wrapped > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorserviceinfo2wrapped__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< RobotRaconteur::ServiceInfo2Wrapped > *result = 0 ;
  
  arg1 = (int)jarg1; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *)new_std_vector_Sl_RobotRaconteur_ServiceInfo2Wrapped_Sg___SWIG_2(arg1);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorserviceinfo2wrapped_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< RobotRaconteur::ServiceInfo2Wrapped > *arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *) 0 ;
  int arg2 ;
  RobotRaconteur::ServiceInfo2Wrapped result;
  
  arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = std_vector_Sl_RobotRaconteur_ServiceInfo2Wrapped_Sg__getitemcopy(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::ServiceInfo2Wrapped((const RobotRaconteur::ServiceInfo2Wrapped &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorserviceinfo2wrapped_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< RobotRaconteur::ServiceInfo2Wrapped > *arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *) 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::ServiceInfo2Wrapped >::value_type *result = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::ServiceInfo2Wrapped >::value_type *) &std_vector_Sl_RobotRaconteur_ServiceInfo2Wrapped_Sg__getitem(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorserviceinfo2wrapped_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::ServiceInfo2Wrapped > *arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *) 0 ;
  int arg2 ;
  RobotRaconteur::ServiceInfo2Wrapped *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (RobotRaconteur::ServiceInfo2Wrapped *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::ServiceInfo2Wrapped const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ServiceInfo2Wrapped_Sg__setitem(arg1,arg2,(RobotRaconteur::ServiceInfo2Wrapped const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorserviceinfo2wrapped_AddRange(void * jarg1, void * jarg2) {
  std::vector< RobotRaconteur::ServiceInfo2Wrapped > *arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *) 0 ;
  std::vector< RobotRaconteur::ServiceInfo2Wrapped > *arg2 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *)jarg1; 
  arg2 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::ServiceInfo2Wrapped > const & type is null", 0);
    return ;
  } 
  
  try {
    std_vector_Sl_RobotRaconteur_ServiceInfo2Wrapped_Sg__AddRange(arg1,(std::vector< RobotRaconteur::ServiceInfo2Wrapped > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorserviceinfo2wrapped_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< RobotRaconteur::ServiceInfo2Wrapped > *arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< RobotRaconteur::ServiceInfo2Wrapped > *result = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *)std_vector_Sl_RobotRaconteur_ServiceInfo2Wrapped_Sg__GetRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorserviceinfo2wrapped_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::ServiceInfo2Wrapped > *arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *) 0 ;
  int arg2 ;
  RobotRaconteur::ServiceInfo2Wrapped *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (RobotRaconteur::ServiceInfo2Wrapped *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::ServiceInfo2Wrapped const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ServiceInfo2Wrapped_Sg__Insert(arg1,arg2,(RobotRaconteur::ServiceInfo2Wrapped const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorserviceinfo2wrapped_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::ServiceInfo2Wrapped > *arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *) 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::ServiceInfo2Wrapped > *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::ServiceInfo2Wrapped > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ServiceInfo2Wrapped_Sg__InsertRange(arg1,arg2,(std::vector< RobotRaconteur::ServiceInfo2Wrapped > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorserviceinfo2wrapped_RemoveAt(void * jarg1, int jarg2) {
  std::vector< RobotRaconteur::ServiceInfo2Wrapped > *arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ServiceInfo2Wrapped_Sg__RemoveAt(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorserviceinfo2wrapped_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< RobotRaconteur::ServiceInfo2Wrapped > *arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ServiceInfo2Wrapped_Sg__RemoveRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorserviceinfo2wrapped_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  RobotRaconteur::ServiceInfo2Wrapped *arg1 = 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::ServiceInfo2Wrapped > *result = 0 ;
  
  arg1 = (RobotRaconteur::ServiceInfo2Wrapped *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::ServiceInfo2Wrapped const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *)std_vector_Sl_RobotRaconteur_ServiceInfo2Wrapped_Sg__Repeat((RobotRaconteur::ServiceInfo2Wrapped const &)*arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorserviceinfo2wrapped_Reverse__SWIG_0(void * jarg1) {
  std::vector< RobotRaconteur::ServiceInfo2Wrapped > *arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *) 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *)jarg1; 
  
  try {
    std_vector_Sl_RobotRaconteur_ServiceInfo2Wrapped_Sg__Reverse__SWIG_0(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorserviceinfo2wrapped_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< RobotRaconteur::ServiceInfo2Wrapped > *arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ServiceInfo2Wrapped_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorserviceinfo2wrapped_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::ServiceInfo2Wrapped > *arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *) 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::ServiceInfo2Wrapped > *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::ServiceInfo2Wrapped > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ServiceInfo2Wrapped_Sg__SetRange(arg1,arg2,(std::vector< RobotRaconteur::ServiceInfo2Wrapped > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_vectorserviceinfo2wrapped(void * jarg1) {
  std::vector< RobotRaconteur::ServiceInfo2Wrapped > *arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *) 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceInfo2Wrapped > *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedNodeInfo2_NodeID_set(void * jarg1, void * jarg2) {
  RobotRaconteur::NodeInfo2 *arg1 = (RobotRaconteur::NodeInfo2 *) 0 ;
  RobotRaconteur::NodeID *arg2 = (RobotRaconteur::NodeID *) 0 ;
  
  arg1 = (RobotRaconteur::NodeInfo2 *)jarg1; 
  arg2 = (RobotRaconteur::NodeID *)jarg2; 
  if (arg1) (arg1)->NodeID = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedNodeInfo2_NodeID_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::NodeInfo2 *arg1 = (RobotRaconteur::NodeInfo2 *) 0 ;
  RobotRaconteur::NodeID *result = 0 ;
  
  arg1 = (RobotRaconteur::NodeInfo2 *)jarg1; 
  result = (RobotRaconteur::NodeID *)& ((arg1)->NodeID);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedNodeInfo2_NodeName_set(void * jarg1, char * jarg2) {
  RobotRaconteur::NodeInfo2 *arg1 = (RobotRaconteur::NodeInfo2 *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::NodeInfo2 *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->NodeName = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_WrappedNodeInfo2_NodeName_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::NodeInfo2 *arg1 = (RobotRaconteur::NodeInfo2 *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (RobotRaconteur::NodeInfo2 *)jarg1; 
  result = (std::string *) & ((arg1)->NodeName);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedNodeInfo2_ConnectionURL_set(void * jarg1, void * jarg2) {
  RobotRaconteur::NodeInfo2 *arg1 = (RobotRaconteur::NodeInfo2 *) 0 ;
  std::vector< std::string > *arg2 = (std::vector< std::string > *) 0 ;
  
  arg1 = (RobotRaconteur::NodeInfo2 *)jarg1; 
  arg2 = (std::vector< std::string > *)jarg2; 
  if (arg1) (arg1)->ConnectionURL = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedNodeInfo2_ConnectionURL_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::NodeInfo2 *arg1 = (RobotRaconteur::NodeInfo2 *) 0 ;
  std::vector< std::string > *result = 0 ;
  
  arg1 = (RobotRaconteur::NodeInfo2 *)jarg1; 
  result = (std::vector< std::string > *)& ((arg1)->ConnectionURL);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedNodeInfo2() {
  void * jresult ;
  RobotRaconteur::NodeInfo2 *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::NodeInfo2 *)new RobotRaconteur::NodeInfo2();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedNodeInfo2(void * jarg1) {
  RobotRaconteur::NodeInfo2 *arg1 = (RobotRaconteur::NodeInfo2 *) 0 ;
  
  arg1 = (RobotRaconteur::NodeInfo2 *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedFindNodeByID(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  RobotRaconteur::NodeID arg2 ;
  std::vector< std::string > *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  RobotRaconteur::NodeID *argp2 ;
  std::vector< RobotRaconteur::NodeInfo2 > result;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  argp2 = (RobotRaconteur::NodeID *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null RobotRaconteur::NodeID", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (std::vector< std::string > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = RobotRaconteur::WrappedFindNodeByID((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1,arg2,(std::vector< std::string > const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< RobotRaconteur::NodeInfo2 >((const std::vector< RobotRaconteur::NodeInfo2 > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedFindNodeByName(void * jarg1, char * jarg2, void * jarg3) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string > *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  std::vector< RobotRaconteur::NodeInfo2 > result;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (std::vector< std::string > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = RobotRaconteur::WrappedFindNodeByName((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1,(std::string const &)*arg2,(std::vector< std::string > const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< RobotRaconteur::NodeInfo2 >((const std::vector< RobotRaconteur::NodeInfo2 > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AsyncWrappedFindNodeByID(void * jarg1, void * jarg2, void * jarg3, int jarg4, void * jarg5, int jarg6) {
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  RobotRaconteur::NodeID *arg2 = 0 ;
  std::vector< std::string > *arg3 = 0 ;
  int32_t arg4 ;
  RobotRaconteur::AsyncNodeInfo2VectorReturnDirector *arg5 = (RobotRaconteur::AsyncNodeInfo2VectorReturnDirector *) 0 ;
  int32_t arg6 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  arg2 = (RobotRaconteur::NodeID *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::NodeID const & type is null", 0);
    return ;
  } 
  arg3 = (std::vector< std::string > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return ;
  } 
  arg4 = (int32_t)jarg4; 
  arg5 = (RobotRaconteur::AsyncNodeInfo2VectorReturnDirector *)jarg5; 
  arg6 = (int32_t)jarg6; 
  
  try {
    RobotRaconteur::AsyncWrappedFindNodeByID((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1,(RobotRaconteur::NodeID const &)*arg2,(std::vector< std::string > const &)*arg3,arg4,arg5,arg6);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AsyncWrappedFindNodeByName(void * jarg1, char * jarg2, void * jarg3, int jarg4, void * jarg5, int jarg6) {
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string > *arg3 = 0 ;
  int32_t arg4 ;
  RobotRaconteur::AsyncNodeInfo2VectorReturnDirector *arg5 = (RobotRaconteur::AsyncNodeInfo2VectorReturnDirector *) 0 ;
  int32_t arg6 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (std::vector< std::string > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return ;
  } 
  arg4 = (int32_t)jarg4; 
  arg5 = (RobotRaconteur::AsyncNodeInfo2VectorReturnDirector *)jarg5; 
  arg6 = (int32_t)jarg6; 
  
  try {
    RobotRaconteur::AsyncWrappedFindNodeByName((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1,(std::string const &)*arg2,(std::vector< std::string > const &)*arg3,arg4,arg5,arg6);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedUpdateDetectedNodes(void * jarg1, void * jarg2) {
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  std::vector< std::string > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  arg2 = (std::vector< std::string > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return ;
  } 
  
  try {
    RobotRaconteur::WrappedUpdateDetectedNodes((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1,(std::vector< std::string > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_AsyncWrappedUpdateDetectedNodes(void * jarg1, void * jarg2, int jarg3, void * jarg4, int jarg5) {
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  std::vector< std::string > *arg2 = 0 ;
  int32_t arg3 ;
  RobotRaconteur::AsyncVoidNoErrReturnDirector *arg4 = (RobotRaconteur::AsyncVoidNoErrReturnDirector *) 0 ;
  int32_t arg5 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  arg2 = (std::vector< std::string > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return ;
  } 
  arg3 = (int32_t)jarg3; 
  arg4 = (RobotRaconteur::AsyncVoidNoErrReturnDirector *)jarg4; 
  arg5 = (int32_t)jarg5; 
  
  try {
    RobotRaconteur::AsyncWrappedUpdateDetectedNodes((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1,(std::vector< std::string > const &)*arg2,arg3,arg4,arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedGetDetectedNodes(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  std::vector< std::string > result;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  
  try {
    result = RobotRaconteur::WrappedGetDetectedNodes((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< std::string >((const std::vector< std::string > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedGetDetectedNodeCacheInfo(void * jarg1, void * jarg2) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  RobotRaconteur::NodeID *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  RobotRaconteur::NodeInfo2 result;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  arg2 = (RobotRaconteur::NodeID *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::NodeID const & type is null", 0);
    return 0;
  } 
  
  try {
    result = RobotRaconteur::WrappedGetDetectedNodeCacheInfo((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1,(RobotRaconteur::NodeID const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::NodeInfo2((const RobotRaconteur::NodeInfo2 &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedTryGetDetectedNodeCacheInfo(void * jarg1, void * jarg2, void * jarg3) {
  unsigned int jresult ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  RobotRaconteur::NodeID *arg2 = 0 ;
  RobotRaconteur::NodeInfo2 *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  bool result;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  arg2 = (RobotRaconteur::NodeID *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::NodeID const & type is null", 0);
    return 0;
  } 
  arg3 = (RobotRaconteur::NodeInfo2 *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::NodeInfo2 & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)RobotRaconteur::WrappedTryGetDetectedNodeCacheInfo((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1,(RobotRaconteur::NodeID const &)*arg2,*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectornodeinfo2_Clear(void * jarg1) {
  std::vector< RobotRaconteur::NodeInfo2 > *arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *) 0 ;
  
  arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *)jarg1; 
  
  try {
    (arg1)->clear();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectornodeinfo2_Add(void * jarg1, void * jarg2) {
  std::vector< RobotRaconteur::NodeInfo2 > *arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *) 0 ;
  RobotRaconteur::NodeInfo2 *arg2 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *)jarg1; 
  arg2 = (RobotRaconteur::NodeInfo2 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::NodeInfo2 const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->push_back((RobotRaconteur::NodeInfo2 const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectornodeinfo2_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< RobotRaconteur::NodeInfo2 > *arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *) 0 ;
  std::vector< RobotRaconteur::NodeInfo2 >::size_type result;
  
  arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *)jarg1; 
  
  try {
    result = ((std::vector< RobotRaconteur::NodeInfo2 > const *)arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectornodeinfo2_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< RobotRaconteur::NodeInfo2 > *arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *) 0 ;
  std::vector< RobotRaconteur::NodeInfo2 >::size_type result;
  
  arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *)jarg1; 
  
  try {
    result = ((std::vector< RobotRaconteur::NodeInfo2 > const *)arg1)->capacity();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectornodeinfo2_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< RobotRaconteur::NodeInfo2 > *arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *) 0 ;
  std::vector< RobotRaconteur::NodeInfo2 >::size_type arg2 ;
  
  arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *)jarg1; 
  arg2 = (std::vector< RobotRaconteur::NodeInfo2 >::size_type)jarg2; 
  
  try {
    (arg1)->reserve(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectornodeinfo2__SWIG_0() {
  void * jresult ;
  std::vector< RobotRaconteur::NodeInfo2 > *result = 0 ;
  
  
  try {
    result = (std::vector< RobotRaconteur::NodeInfo2 > *)new std::vector< RobotRaconteur::NodeInfo2 >();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectornodeinfo2__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< RobotRaconteur::NodeInfo2 > *arg1 = 0 ;
  std::vector< RobotRaconteur::NodeInfo2 > *result = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::NodeInfo2 > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (std::vector< RobotRaconteur::NodeInfo2 > *)new std::vector< RobotRaconteur::NodeInfo2 >((std::vector< RobotRaconteur::NodeInfo2 > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectornodeinfo2__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< RobotRaconteur::NodeInfo2 > *result = 0 ;
  
  arg1 = (int)jarg1; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::NodeInfo2 > *)new_std_vector_Sl_RobotRaconteur_NodeInfo2_Sg___SWIG_2(arg1);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectornodeinfo2_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< RobotRaconteur::NodeInfo2 > *arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *) 0 ;
  int arg2 ;
  RobotRaconteur::NodeInfo2 result;
  
  arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = std_vector_Sl_RobotRaconteur_NodeInfo2_Sg__getitemcopy(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::NodeInfo2((const RobotRaconteur::NodeInfo2 &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectornodeinfo2_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< RobotRaconteur::NodeInfo2 > *arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *) 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::NodeInfo2 >::value_type *result = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::NodeInfo2 >::value_type *) &std_vector_Sl_RobotRaconteur_NodeInfo2_Sg__getitem(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectornodeinfo2_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::NodeInfo2 > *arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *) 0 ;
  int arg2 ;
  RobotRaconteur::NodeInfo2 *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (RobotRaconteur::NodeInfo2 *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::NodeInfo2 const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_NodeInfo2_Sg__setitem(arg1,arg2,(RobotRaconteur::NodeInfo2 const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectornodeinfo2_AddRange(void * jarg1, void * jarg2) {
  std::vector< RobotRaconteur::NodeInfo2 > *arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *) 0 ;
  std::vector< RobotRaconteur::NodeInfo2 > *arg2 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *)jarg1; 
  arg2 = (std::vector< RobotRaconteur::NodeInfo2 > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::NodeInfo2 > const & type is null", 0);
    return ;
  } 
  
  try {
    std_vector_Sl_RobotRaconteur_NodeInfo2_Sg__AddRange(arg1,(std::vector< RobotRaconteur::NodeInfo2 > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectornodeinfo2_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< RobotRaconteur::NodeInfo2 > *arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< RobotRaconteur::NodeInfo2 > *result = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::NodeInfo2 > *)std_vector_Sl_RobotRaconteur_NodeInfo2_Sg__GetRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectornodeinfo2_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::NodeInfo2 > *arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *) 0 ;
  int arg2 ;
  RobotRaconteur::NodeInfo2 *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (RobotRaconteur::NodeInfo2 *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::NodeInfo2 const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_NodeInfo2_Sg__Insert(arg1,arg2,(RobotRaconteur::NodeInfo2 const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectornodeinfo2_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::NodeInfo2 > *arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *) 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::NodeInfo2 > *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< RobotRaconteur::NodeInfo2 > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::NodeInfo2 > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_NodeInfo2_Sg__InsertRange(arg1,arg2,(std::vector< RobotRaconteur::NodeInfo2 > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectornodeinfo2_RemoveAt(void * jarg1, int jarg2) {
  std::vector< RobotRaconteur::NodeInfo2 > *arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_NodeInfo2_Sg__RemoveAt(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectornodeinfo2_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< RobotRaconteur::NodeInfo2 > *arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_NodeInfo2_Sg__RemoveRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectornodeinfo2_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  RobotRaconteur::NodeInfo2 *arg1 = 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::NodeInfo2 > *result = 0 ;
  
  arg1 = (RobotRaconteur::NodeInfo2 *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::NodeInfo2 const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::NodeInfo2 > *)std_vector_Sl_RobotRaconteur_NodeInfo2_Sg__Repeat((RobotRaconteur::NodeInfo2 const &)*arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectornodeinfo2_Reverse__SWIG_0(void * jarg1) {
  std::vector< RobotRaconteur::NodeInfo2 > *arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *) 0 ;
  
  arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *)jarg1; 
  
  try {
    std_vector_Sl_RobotRaconteur_NodeInfo2_Sg__Reverse__SWIG_0(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectornodeinfo2_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< RobotRaconteur::NodeInfo2 > *arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_NodeInfo2_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectornodeinfo2_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::NodeInfo2 > *arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *) 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::NodeInfo2 > *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< RobotRaconteur::NodeInfo2 > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::NodeInfo2 > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_NodeInfo2_Sg__SetRange(arg1,arg2,(std::vector< RobotRaconteur::NodeInfo2 > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_vectornodeinfo2(void * jarg1) {
  std::vector< RobotRaconteur::NodeInfo2 > *arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *) 0 ;
  
  arg1 = (std::vector< RobotRaconteur::NodeInfo2 > *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_map_subscriptionserviceinfo2__SWIG_0() {
  void * jresult ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *result = 0 ;
  
  
  try {
    result = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *)new std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_map_subscriptionserviceinfo2__SWIG_1(void * jarg1) {
  void * jresult ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *arg1 = 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *result = 0 ;
  
  arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *)new std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >((std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionserviceinfo2_size(void * jarg1) {
  unsigned long jresult ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *) 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::size_type result;
  
  arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *)jarg1; 
  
  try {
    result = ((std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > const *)arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionserviceinfo2_empty(void * jarg1) {
  unsigned int jresult ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *) 0 ;
  bool result;
  
  arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *)jarg1; 
  
  try {
    result = (bool)((std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > const *)arg1)->empty();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionserviceinfo2_Clear(void * jarg1) {
  std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *) 0 ;
  
  arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *)jarg1; 
  
  try {
    (arg1)->clear();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionserviceinfo2_getitem(void * jarg1, void * jarg2) {
  void * jresult ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *) 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::key_type *arg2 = 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::mapped_type *result = 0 ;
  
  arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *)jarg1; 
  arg2 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::key_type *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::key_type const & type is null", 0);
    return 0;
  } 
  
  try {
    try {
      result = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::mapped_type *) &std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_RobotRaconteur_ServiceInfo2Wrapped_Sg__getitem(arg1,(RobotRaconteur::ServiceSubscriptionClientID const &)*arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionserviceinfo2_setitem(void * jarg1, void * jarg2, void * jarg3) {
  std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *) 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::key_type *arg2 = 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::mapped_type *arg3 = 0 ;
  
  arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *)jarg1; 
  arg2 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::key_type *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::key_type const & type is null", 0);
    return ;
  } 
  arg3 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::mapped_type *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::mapped_type const & type is null", 0);
    return ;
  } 
  
  try {
    std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_RobotRaconteur_ServiceInfo2Wrapped_Sg__setitem(arg1,(RobotRaconteur::ServiceSubscriptionClientID const &)*arg2,(RobotRaconteur::ServiceInfo2Wrapped const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionserviceinfo2_ContainsKey(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *) 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::key_type *arg2 = 0 ;
  bool result;
  
  arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *)jarg1; 
  arg2 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::key_type *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::key_type const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_RobotRaconteur_ServiceInfo2Wrapped_Sg__ContainsKey(arg1,(RobotRaconteur::ServiceSubscriptionClientID const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionserviceinfo2_Add(void * jarg1, void * jarg2, void * jarg3) {
  std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *) 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::key_type *arg2 = 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::mapped_type *arg3 = 0 ;
  
  arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *)jarg1; 
  arg2 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::key_type *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::key_type const & type is null", 0);
    return ;
  } 
  arg3 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::mapped_type *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::mapped_type const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_RobotRaconteur_ServiceInfo2Wrapped_Sg__Add(arg1,(RobotRaconteur::ServiceSubscriptionClientID const &)*arg2,(RobotRaconteur::ServiceInfo2Wrapped const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionserviceinfo2_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *) 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::key_type *arg2 = 0 ;
  bool result;
  
  arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *)jarg1; 
  arg2 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::key_type *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::key_type const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_RobotRaconteur_ServiceInfo2Wrapped_Sg__Remove(arg1,(RobotRaconteur::ServiceSubscriptionClientID const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionserviceinfo2_create_iterator_begin(void * jarg1) {
  void * jresult ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *) 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped,std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator *result = 0 ;
  
  arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *)jarg1; 
  
  try {
    result = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped,std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator *)std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_RobotRaconteur_ServiceInfo2Wrapped_Sg__create_iterator_begin(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionserviceinfo2_get_next_key(void * jarg1, void * jarg2) {
  void * jresult ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *) 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped,std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator *arg2 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped,std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator *) 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::key_type *result = 0 ;
  
  arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *)jarg1; 
  arg2 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped,std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator *)jarg2; 
  
  try {
    result = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped >::key_type *) &std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_RobotRaconteur_ServiceInfo2Wrapped_Sg__get_next_key(arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionserviceinfo2_destroy_iterator(void * jarg1, void * jarg2) {
  std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *) 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped,std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator *arg2 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped,std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator *) 0 ;
  
  arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *)jarg1; 
  arg2 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped,std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator *)jarg2; 
  
  try {
    std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_RobotRaconteur_ServiceInfo2Wrapped_Sg__destroy_iterator(arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_map_subscriptionserviceinfo2(void * jarg1) {
  std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *) 0 ;
  
  arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped > *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_map_subscriptionclients__SWIG_0() {
  void * jresult ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *result = 0 ;
  
  
  try {
    result = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *)new std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_map_subscriptionclients__SWIG_1(void * jarg1) {
  void * jresult ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *arg1 = 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *result = 0 ;
  
  arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *)new std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >((std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionclients_size(void * jarg1) {
  unsigned long jresult ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *) 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::size_type result;
  
  arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *)jarg1; 
  
  try {
    result = ((std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > const *)arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionclients_empty(void * jarg1) {
  unsigned int jresult ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *) 0 ;
  bool result;
  
  arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *)jarg1; 
  
  try {
    result = (bool)((std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > const *)arg1)->empty();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionclients_Clear(void * jarg1) {
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *) 0 ;
  
  arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *)jarg1; 
  
  try {
    (arg1)->clear();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionclients_getitem(void * jarg1, void * jarg2) {
  void * jresult ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *) 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::key_type *arg2 = 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::mapped_type *result = 0 ;
  
  arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *)jarg1; 
  arg2 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::key_type *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::key_type const & type is null", 0);
    return 0;
  } 
  
  try {
    try {
      result = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::mapped_type *) &std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceStub_Sg__Sg__getitem(arg1,(RobotRaconteur::ServiceSubscriptionClientID const &)*arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = *result ? new std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::mapped_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionclients_setitem(void * jarg1, void * jarg2, void * jarg3) {
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *) 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::key_type *arg2 = 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::mapped_type *arg3 = 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::mapped_type tempnull3 ;
  
  arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *)jarg1; 
  arg2 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::key_type *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::key_type const & type is null", 0);
    return ;
  } 
  arg3 = jarg3 ? (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::mapped_type *)jarg3 : &tempnull3; 
  
  try {
    std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceStub_Sg__Sg__setitem(arg1,(RobotRaconteur::ServiceSubscriptionClientID const &)*arg2,(boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionclients_ContainsKey(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *) 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::key_type *arg2 = 0 ;
  bool result;
  
  arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *)jarg1; 
  arg2 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::key_type *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::key_type const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceStub_Sg__Sg__ContainsKey(arg1,(RobotRaconteur::ServiceSubscriptionClientID const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionclients_Add(void * jarg1, void * jarg2, void * jarg3) {
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *) 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::key_type *arg2 = 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::mapped_type *arg3 = 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::mapped_type tempnull3 ;
  
  arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *)jarg1; 
  arg2 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::key_type *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::key_type const & type is null", 0);
    return ;
  } 
  arg3 = jarg3 ? (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::mapped_type *)jarg3 : &tempnull3; 
  
  try {
    try {
      std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceStub_Sg__Sg__Add(arg1,(RobotRaconteur::ServiceSubscriptionClientID const &)*arg2,(boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionclients_Remove(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *) 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::key_type *arg2 = 0 ;
  bool result;
  
  arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *)jarg1; 
  arg2 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::key_type *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::key_type const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceStub_Sg__Sg__Remove(arg1,(RobotRaconteur::ServiceSubscriptionClientID const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionclients_create_iterator_begin(void * jarg1) {
  void * jresult ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *) 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub >,std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator *result = 0 ;
  
  arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *)jarg1; 
  
  try {
    result = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub >,std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator *)std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceStub_Sg__Sg__create_iterator_begin(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionclients_get_next_key(void * jarg1, void * jarg2) {
  void * jresult ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *) 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub >,std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator *arg2 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub >,std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator *) 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::key_type *result = 0 ;
  
  arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *)jarg1; 
  arg2 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub >,std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator *)jarg2; 
  
  try {
    result = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > >::key_type *) &std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceStub_Sg__Sg__get_next_key(arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionclients_destroy_iterator(void * jarg1, void * jarg2) {
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *) 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub >,std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator *arg2 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub >,std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator *) 0 ;
  
  arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *)jarg1; 
  arg2 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub >,std::less< RobotRaconteur::ServiceSubscriptionClientID > >::iterator *)jarg2; 
  
  try {
    std_map_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sc_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceStub_Sg__Sg__destroy_iterator(arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_map_subscriptionclients(void * jarg1) {
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *) 0 ;
  
  arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub > > *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_wrappedservicesubscriptionnode_Clear(void * jarg1) {
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *)jarg1; 
  
  try {
    (arg1)->clear();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_wrappedservicesubscriptionnode_Add(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > tempnull2 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > *)jarg2 : &tempnull2; 
  
  try {
    (arg1)->push_back((boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_wrappedservicesubscriptionnode_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *)jarg1; 
  
  try {
    result = ((std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > const *)arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_wrappedservicesubscriptionnode_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > >::size_type result;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *)jarg1; 
  
  try {
    result = ((std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > const *)arg1)->capacity();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_wrappedservicesubscriptionnode_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > >::size_type arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > >::size_type)jarg2; 
  
  try {
    (arg1)->reserve(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_wrappedservicesubscriptionnode__SWIG_0() {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *result = 0 ;
  
  
  try {
    result = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *)new std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > >();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_wrappedservicesubscriptionnode__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *arg1 = 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *)new std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > >((std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_wrappedservicesubscriptionnode__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *)new_std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Sg__Sg___SWIG_2(arg1);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_wrappedservicesubscriptionnode_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > result;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Sg__Sg__getitemcopy(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_wrappedservicesubscriptionnode_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > >::value_type *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > >::value_type *) &std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Sg__Sg__getitem(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = *result ? new std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > >::value_type(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_wrappedservicesubscriptionnode_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > tempnull3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > *)jarg3 : &tempnull3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Sg__Sg__setitem(arg1,arg2,(boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_wrappedservicesubscriptionnode_AddRange(void * jarg1, void * jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *arg2 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *)jarg1; 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > const & type is null", 0);
    return ;
  } 
  
  try {
    std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Sg__Sg__AddRange(arg1,(std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_wrappedservicesubscriptionnode_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *result = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *)std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Sg__Sg__GetRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_wrappedservicesubscriptionnode_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *) 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > tempnull3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > *)jarg3 : &tempnull3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Sg__Sg__Insert(arg1,arg2,(boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_wrappedservicesubscriptionnode_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Sg__Sg__InsertRange(arg1,arg2,(std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_wrappedservicesubscriptionnode_RemoveAt(void * jarg1, int jarg2) {
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Sg__Sg__RemoveAt(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_wrappedservicesubscriptionnode_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Sg__Sg__RemoveRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_wrappedservicesubscriptionnode_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > *arg1 = 0 ;
  int arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > tempnull1 ;
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > *)jarg1 : &tempnull1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *)std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Sg__Sg__Repeat((boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > const &)*arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_wrappedservicesubscriptionnode_Reverse__SWIG_0(void * jarg1) {
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *)jarg1; 
  
  try {
    std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Sg__Sg__Reverse__SWIG_0(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_wrappedservicesubscriptionnode_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_wrappedservicesubscriptionnode_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *) 0 ;
  int arg2 ;
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *arg3 = 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_boost_shared_ptr_Sl_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Sg__Sg__SetRange(arg1,arg2,(std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_vectorptr_wrappedservicesubscriptionnode(void * jarg1) {
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *) 0 ;
  
  arg1 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_subscriptionclientid_Clear(void * jarg1) {
  std::vector< RobotRaconteur::ServiceSubscriptionClientID > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *) 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *)jarg1; 
  
  try {
    (arg1)->clear();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_subscriptionclientid_Add(void * jarg1, void * jarg2) {
  std::vector< RobotRaconteur::ServiceSubscriptionClientID > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *) 0 ;
  RobotRaconteur::ServiceSubscriptionClientID *arg2 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *)jarg1; 
  arg2 = (RobotRaconteur::ServiceSubscriptionClientID *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::ServiceSubscriptionClientID const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->push_back((RobotRaconteur::ServiceSubscriptionClientID const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_subscriptionclientid_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< RobotRaconteur::ServiceSubscriptionClientID > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *) 0 ;
  std::vector< RobotRaconteur::ServiceSubscriptionClientID >::size_type result;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *)jarg1; 
  
  try {
    result = ((std::vector< RobotRaconteur::ServiceSubscriptionClientID > const *)arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_subscriptionclientid_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< RobotRaconteur::ServiceSubscriptionClientID > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *) 0 ;
  std::vector< RobotRaconteur::ServiceSubscriptionClientID >::size_type result;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *)jarg1; 
  
  try {
    result = ((std::vector< RobotRaconteur::ServiceSubscriptionClientID > const *)arg1)->capacity();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_subscriptionclientid_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< RobotRaconteur::ServiceSubscriptionClientID > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *) 0 ;
  std::vector< RobotRaconteur::ServiceSubscriptionClientID >::size_type arg2 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *)jarg1; 
  arg2 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID >::size_type)jarg2; 
  
  try {
    (arg1)->reserve(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_subscriptionclientid__SWIG_0() {
  void * jresult ;
  std::vector< RobotRaconteur::ServiceSubscriptionClientID > *result = 0 ;
  
  
  try {
    result = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *)new std::vector< RobotRaconteur::ServiceSubscriptionClientID >();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_subscriptionclientid__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< RobotRaconteur::ServiceSubscriptionClientID > *arg1 = 0 ;
  std::vector< RobotRaconteur::ServiceSubscriptionClientID > *result = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::ServiceSubscriptionClientID > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *)new std::vector< RobotRaconteur::ServiceSubscriptionClientID >((std::vector< RobotRaconteur::ServiceSubscriptionClientID > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vectorptr_subscriptionclientid__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< RobotRaconteur::ServiceSubscriptionClientID > *result = 0 ;
  
  arg1 = (int)jarg1; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *)new_std_vector_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sg___SWIG_2(arg1);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_subscriptionclientid_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< RobotRaconteur::ServiceSubscriptionClientID > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *) 0 ;
  int arg2 ;
  RobotRaconteur::ServiceSubscriptionClientID result;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = std_vector_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sg__getitemcopy(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::ServiceSubscriptionClientID((const RobotRaconteur::ServiceSubscriptionClientID &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_subscriptionclientid_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< RobotRaconteur::ServiceSubscriptionClientID > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *) 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::ServiceSubscriptionClientID >::value_type *result = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::ServiceSubscriptionClientID >::value_type *) &std_vector_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sg__getitem(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_subscriptionclientid_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::ServiceSubscriptionClientID > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *) 0 ;
  int arg2 ;
  RobotRaconteur::ServiceSubscriptionClientID *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (RobotRaconteur::ServiceSubscriptionClientID *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::ServiceSubscriptionClientID const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sg__setitem(arg1,arg2,(RobotRaconteur::ServiceSubscriptionClientID const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_subscriptionclientid_AddRange(void * jarg1, void * jarg2) {
  std::vector< RobotRaconteur::ServiceSubscriptionClientID > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *) 0 ;
  std::vector< RobotRaconteur::ServiceSubscriptionClientID > *arg2 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *)jarg1; 
  arg2 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::ServiceSubscriptionClientID > const & type is null", 0);
    return ;
  } 
  
  try {
    std_vector_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sg__AddRange(arg1,(std::vector< RobotRaconteur::ServiceSubscriptionClientID > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_subscriptionclientid_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< RobotRaconteur::ServiceSubscriptionClientID > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< RobotRaconteur::ServiceSubscriptionClientID > *result = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *)std_vector_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sg__GetRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_subscriptionclientid_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::ServiceSubscriptionClientID > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *) 0 ;
  int arg2 ;
  RobotRaconteur::ServiceSubscriptionClientID *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (RobotRaconteur::ServiceSubscriptionClientID *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::ServiceSubscriptionClientID const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sg__Insert(arg1,arg2,(RobotRaconteur::ServiceSubscriptionClientID const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_subscriptionclientid_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::ServiceSubscriptionClientID > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *) 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::ServiceSubscriptionClientID > *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::ServiceSubscriptionClientID > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sg__InsertRange(arg1,arg2,(std::vector< RobotRaconteur::ServiceSubscriptionClientID > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_subscriptionclientid_RemoveAt(void * jarg1, int jarg2) {
  std::vector< RobotRaconteur::ServiceSubscriptionClientID > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sg__RemoveAt(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_subscriptionclientid_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< RobotRaconteur::ServiceSubscriptionClientID > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sg__RemoveRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_subscriptionclientid_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  RobotRaconteur::ServiceSubscriptionClientID *arg1 = 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::ServiceSubscriptionClientID > *result = 0 ;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionClientID *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::ServiceSubscriptionClientID const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *)std_vector_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sg__Repeat((RobotRaconteur::ServiceSubscriptionClientID const &)*arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_subscriptionclientid_Reverse__SWIG_0(void * jarg1) {
  std::vector< RobotRaconteur::ServiceSubscriptionClientID > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *) 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *)jarg1; 
  
  try {
    std_vector_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sg__Reverse__SWIG_0(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_subscriptionclientid_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< RobotRaconteur::ServiceSubscriptionClientID > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vectorptr_subscriptionclientid_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::ServiceSubscriptionClientID > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *) 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::ServiceSubscriptionClientID > *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::ServiceSubscriptionClientID > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ServiceSubscriptionClientID_Sg__SetRange(arg1,arg2,(std::vector< RobotRaconteur::ServiceSubscriptionClientID > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_vectorptr_subscriptionclientid(void * jarg1) {
  std::vector< RobotRaconteur::ServiceSubscriptionClientID > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *) 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionClientID > *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_wrappedservicesubscriptionmanagerdetails_Clear(void * jarg1) {
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *) 0 ;
  
  arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *)jarg1; 
  
  try {
    (arg1)->clear();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_wrappedservicesubscriptionmanagerdetails_Add(void * jarg1, void * jarg2) {
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *) 0 ;
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *arg2 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *)jarg1; 
  arg2 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::WrappedServiceSubscriptionManagerDetails const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->push_back((RobotRaconteur::WrappedServiceSubscriptionManagerDetails const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vector_wrappedservicesubscriptionmanagerdetails_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *) 0 ;
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails >::size_type result;
  
  arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *)jarg1; 
  
  try {
    result = ((std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > const *)arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vector_wrappedservicesubscriptionmanagerdetails_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *) 0 ;
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails >::size_type result;
  
  arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *)jarg1; 
  
  try {
    result = ((std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > const *)arg1)->capacity();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_wrappedservicesubscriptionmanagerdetails_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *) 0 ;
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails >::size_type arg2 ;
  
  arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *)jarg1; 
  arg2 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails >::size_type)jarg2; 
  
  try {
    (arg1)->reserve(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vector_wrappedservicesubscriptionmanagerdetails__SWIG_0() {
  void * jresult ;
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *result = 0 ;
  
  
  try {
    result = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *)new std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails >();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vector_wrappedservicesubscriptionmanagerdetails__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *arg1 = 0 ;
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *result = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *)new std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails >((std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vector_wrappedservicesubscriptionmanagerdetails__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *result = 0 ;
  
  arg1 = (int)jarg1; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *)new_std_vector_Sl_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Sg___SWIG_2(arg1);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vector_wrappedservicesubscriptionmanagerdetails_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *) 0 ;
  int arg2 ;
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails result;
  
  arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = std_vector_Sl_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Sg__getitemcopy(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::WrappedServiceSubscriptionManagerDetails((const RobotRaconteur::WrappedServiceSubscriptionManagerDetails &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vector_wrappedservicesubscriptionmanagerdetails_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *) 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails >::value_type *result = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails >::value_type *) &std_vector_Sl_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Sg__getitem(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_wrappedservicesubscriptionmanagerdetails_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *) 0 ;
  int arg2 ;
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::WrappedServiceSubscriptionManagerDetails const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Sg__setitem(arg1,arg2,(RobotRaconteur::WrappedServiceSubscriptionManagerDetails const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_wrappedservicesubscriptionmanagerdetails_AddRange(void * jarg1, void * jarg2) {
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *) 0 ;
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *arg2 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *)jarg1; 
  arg2 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > const & type is null", 0);
    return ;
  } 
  
  try {
    std_vector_Sl_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Sg__AddRange(arg1,(std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vector_wrappedservicesubscriptionmanagerdetails_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *result = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *)std_vector_Sl_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Sg__GetRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_wrappedservicesubscriptionmanagerdetails_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *) 0 ;
  int arg2 ;
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::WrappedServiceSubscriptionManagerDetails const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Sg__Insert(arg1,arg2,(RobotRaconteur::WrappedServiceSubscriptionManagerDetails const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_wrappedservicesubscriptionmanagerdetails_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *) 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Sg__InsertRange(arg1,arg2,(std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_wrappedservicesubscriptionmanagerdetails_RemoveAt(void * jarg1, int jarg2) {
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Sg__RemoveAt(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_wrappedservicesubscriptionmanagerdetails_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Sg__RemoveRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vector_wrappedservicesubscriptionmanagerdetails_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *arg1 = 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *result = 0 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::WrappedServiceSubscriptionManagerDetails const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *)std_vector_Sl_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Sg__Repeat((RobotRaconteur::WrappedServiceSubscriptionManagerDetails const &)*arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_wrappedservicesubscriptionmanagerdetails_Reverse__SWIG_0(void * jarg1) {
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *) 0 ;
  
  arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *)jarg1; 
  
  try {
    std_vector_Sl_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Sg__Reverse__SWIG_0(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_wrappedservicesubscriptionmanagerdetails_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_wrappedservicesubscriptionmanagerdetails_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *) 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Sg__SetRange(arg1,arg2,(std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_vector_wrappedservicesubscriptionmanagerdetails(void * jarg1) {
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *) 0 ;
  
  arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceSubscriptionFilterAttribute_Name_set(void * jarg1, char * jarg2) {
  RobotRaconteur::ServiceSubscriptionFilterAttribute *arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttribute *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttribute *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->Name = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ServiceSubscriptionFilterAttribute_Name_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::ServiceSubscriptionFilterAttribute *arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttribute *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttribute *)jarg1; 
  result = (std::string *) & ((arg1)->Name);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceSubscriptionFilterAttribute_Value_set(void * jarg1, char * jarg2) {
  RobotRaconteur::ServiceSubscriptionFilterAttribute *arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttribute *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttribute *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->Value = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_ServiceSubscriptionFilterAttribute_Value_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::ServiceSubscriptionFilterAttribute *arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttribute *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttribute *)jarg1; 
  result = (std::string *) & ((arg1)->Value);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceSubscriptionFilterAttribute_UseRegex_set(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::ServiceSubscriptionFilterAttribute *arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttribute *) 0 ;
  bool arg2 ;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttribute *)jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->UseRegex = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_ServiceSubscriptionFilterAttribute_UseRegex_get(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::ServiceSubscriptionFilterAttribute *arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttribute *) 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttribute *)jarg1; 
  result = (bool) ((arg1)->UseRegex);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_ServiceSubscriptionFilterAttribute__SWIG_0(char * jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  RobotRaconteur::ServiceSubscriptionFilterAttribute *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  
  try {
    result = (RobotRaconteur::ServiceSubscriptionFilterAttribute *)new RobotRaconteur::ServiceSubscriptionFilterAttribute((std::string const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_ServiceSubscriptionFilterAttribute__SWIG_1(char * jarg1, char * jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  RobotRaconteur::ServiceSubscriptionFilterAttribute *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (RobotRaconteur::ServiceSubscriptionFilterAttribute *)new RobotRaconteur::ServiceSubscriptionFilterAttribute((std::string const &)*arg1,(std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_ServiceSubscriptionFilterAttribute_IsMatch__SWIG_0(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::ServiceSubscriptionFilterAttribute *arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttribute *) 0 ;
  std::string *arg2 = 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttribute *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (bool)((RobotRaconteur::ServiceSubscriptionFilterAttribute const *)arg1)->IsMatch((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_ServiceSubscriptionFilterAttribute_IsMatch__SWIG_1(void * jarg1, char * jarg2, char * jarg3) {
  unsigned int jresult ;
  RobotRaconteur::ServiceSubscriptionFilterAttribute *arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttribute *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttribute *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  try {
    result = (bool)((RobotRaconteur::ServiceSubscriptionFilterAttribute const *)arg1)->IsMatch((std::string const &)*arg2,(std::string const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_ServiceSubscriptionFilterAttribute_IsMatch__SWIG_2(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::ServiceSubscriptionFilterAttribute *arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttribute *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttribute *)jarg1; 
  arg2 = (std::vector< std::string > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)((RobotRaconteur::ServiceSubscriptionFilterAttribute const *)arg1)->IsMatch((std::vector< std::string > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_ServiceSubscriptionFilterAttribute_IsMatch__SWIG_3(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::ServiceSubscriptionFilterAttribute *arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttribute *) 0 ;
  std::map< std::string,std::string,std::less< std::string > > *arg2 = 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttribute *)jarg1; 
  arg2 = (std::map< std::string,std::string,std::less< std::string > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< std::string,std::string,std::less< std::string > > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)((RobotRaconteur::ServiceSubscriptionFilterAttribute const *)arg1)->IsMatch((std::map< std::string,std::string,std::less< std::string > > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_ServiceSubscriptionFilterAttribute(void * jarg1) {
  RobotRaconteur::ServiceSubscriptionFilterAttribute *arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttribute *) 0 ;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttribute *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_CreateServiceSubscriptionFilterAttributeRegex__SWIG_0(char * jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  SwigValueWrapper< RobotRaconteur::ServiceSubscriptionFilterAttribute > result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  
  try {
    result = RobotRaconteur::CreateServiceSubscriptionFilterAttributeRegex((std::string const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::ServiceSubscriptionFilterAttribute((const RobotRaconteur::ServiceSubscriptionFilterAttribute &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_CreateServiceSubscriptionFilterAttributeRegex__SWIG_1(char * jarg1, char * jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  SwigValueWrapper< RobotRaconteur::ServiceSubscriptionFilterAttribute > result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = RobotRaconteur::CreateServiceSubscriptionFilterAttributeRegex((std::string const &)*arg1,(std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::ServiceSubscriptionFilterAttribute((const RobotRaconteur::ServiceSubscriptionFilterAttribute &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_CreateServiceSubscriptionFilterAttributeIdentifier__SWIG_0(char * jarg1, char * jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  SwigValueWrapper< RobotRaconteur::ServiceSubscriptionFilterAttribute > result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = RobotRaconteur::CreateServiceSubscriptionFilterAttributeIdentifier((std::string const &)*arg1,(std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::ServiceSubscriptionFilterAttribute((const RobotRaconteur::ServiceSubscriptionFilterAttribute &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_CreateServiceSubscriptionFilterAttributeIdentifier__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
  void * jresult ;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  SwigValueWrapper< RobotRaconteur::ServiceSubscriptionFilterAttribute > result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  try {
    result = RobotRaconteur::CreateServiceSubscriptionFilterAttributeIdentifier((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::ServiceSubscriptionFilterAttribute((const RobotRaconteur::ServiceSubscriptionFilterAttribute &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_CreateServiceSubscriptionFilterAttributeCombinedIdentifier(char * jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  SwigValueWrapper< RobotRaconteur::ServiceSubscriptionFilterAttribute > result;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  
  try {
    result = RobotRaconteur::CreateServiceSubscriptionFilterAttributeCombinedIdentifier((std::string const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::ServiceSubscriptionFilterAttribute((const RobotRaconteur::ServiceSubscriptionFilterAttribute &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_subscriptionattribute_Clear(void * jarg1) {
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1; 
  
  try {
    (arg1)->clear();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_subscriptionattribute_Add(void * jarg1, void * jarg2) {
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  RobotRaconteur::ServiceSubscriptionFilterAttribute *arg2 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1; 
  arg2 = (RobotRaconteur::ServiceSubscriptionFilterAttribute *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::ServiceSubscriptionFilterAttribute const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->push_back((RobotRaconteur::ServiceSubscriptionFilterAttribute const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vector_subscriptionattribute_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute >::size_type result;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1; 
  
  try {
    result = ((std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > const *)arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_vector_subscriptionattribute_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute >::size_type result;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1; 
  
  try {
    result = ((std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > const *)arg1)->capacity();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_subscriptionattribute_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute >::size_type arg2 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1; 
  arg2 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute >::size_type)jarg2; 
  
  try {
    (arg1)->reserve(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vector_subscriptionattribute__SWIG_0() {
  void * jresult ;
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *result = 0 ;
  
  
  try {
    result = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *)new std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute >();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vector_subscriptionattribute__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = 0 ;
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *result = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *)new std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute >((std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_vector_subscriptionattribute__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *result = 0 ;
  
  arg1 = (int)jarg1; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *)new_std_vector_Sl_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg___SWIG_2(arg1);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vector_subscriptionattribute_getitemcopy(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  int arg2 ;
  SwigValueWrapper< RobotRaconteur::ServiceSubscriptionFilterAttribute > result;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = std_vector_Sl_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__getitemcopy(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::ServiceSubscriptionFilterAttribute((const RobotRaconteur::ServiceSubscriptionFilterAttribute &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vector_subscriptionattribute_getitem(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute >::value_type *result = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute >::value_type *) &std_vector_Sl_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__getitem(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_subscriptionattribute_setitem(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  int arg2 ;
  RobotRaconteur::ServiceSubscriptionFilterAttribute *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (RobotRaconteur::ServiceSubscriptionFilterAttribute *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::ServiceSubscriptionFilterAttribute const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__setitem(arg1,arg2,(RobotRaconteur::ServiceSubscriptionFilterAttribute const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_subscriptionattribute_AddRange(void * jarg1, void * jarg2) {
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg2 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1; 
  arg2 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > const & type is null", 0);
    return ;
  } 
  
  try {
    std_vector_Sl_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__AddRange(arg1,(std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vector_subscriptionattribute_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *result = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *)std_vector_Sl_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__GetRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_subscriptionattribute_Insert(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  int arg2 ;
  RobotRaconteur::ServiceSubscriptionFilterAttribute *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (RobotRaconteur::ServiceSubscriptionFilterAttribute *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::ServiceSubscriptionFilterAttribute const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__Insert(arg1,arg2,(RobotRaconteur::ServiceSubscriptionFilterAttribute const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_subscriptionattribute_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__InsertRange(arg1,arg2,(std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_subscriptionattribute_RemoveAt(void * jarg1, int jarg2) {
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1; 
  arg2 = (int)jarg2; 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__RemoveAt(arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_subscriptionattribute_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__RemoveRange(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_vector_subscriptionattribute_Repeat(void * jarg1, int jarg2) {
  void * jresult ;
  RobotRaconteur::ServiceSubscriptionFilterAttribute *arg1 = 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *result = 0 ;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttribute *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::ServiceSubscriptionFilterAttribute const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  
  try {
    try {
      result = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *)std_vector_Sl_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__Repeat((RobotRaconteur::ServiceSubscriptionFilterAttribute const &)*arg1,arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_subscriptionattribute_Reverse__SWIG_0(void * jarg1) {
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1; 
  
  try {
    std_vector_Sl_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__Reverse__SWIG_0(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_subscriptionattribute_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    } catch(std::invalid_argument &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_vector_subscriptionattribute_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  int arg2 ;
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg3 = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_vector_Sl_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__SetRange(arg1,arg2,(std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_vector_subscriptionattribute(void * jarg1) {
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  
  arg1 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_map_subscriptionattribute__SWIG_0() {
  void * jresult ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *result = 0 ;
  
  
  try {
    result = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *)new std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_map_subscriptionattribute__SWIG_1(void * jarg1) {
  void * jresult ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = 0 ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *result = 0 ;
  
  arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *)new std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >((std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionattribute_size(void * jarg1) {
  unsigned long jresult ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >::size_type result;
  
  arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1; 
  
  try {
    result = ((std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > const *)arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionattribute_empty(void * jarg1) {
  unsigned int jresult ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  bool result;
  
  arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1; 
  
  try {
    result = (bool)((std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > const *)arg1)->empty();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionattribute_Clear(void * jarg1) {
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  
  arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1; 
  
  try {
    (arg1)->clear();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionattribute_getitem(void * jarg1, char * jarg2) {
  void * jresult ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >::key_type *arg2 = 0 ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >::mapped_type *result = 0 ;
  
  arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >::key_type arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    try {
      result = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >::mapped_type *) &std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__getitem(arg1,(std::string const &)*arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionattribute_setitem(void * jarg1, char * jarg2, void * jarg3) {
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >::key_type *arg2 = 0 ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >::mapped_type *arg3 = 0 ;
  
  arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >::key_type arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >::mapped_type *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >::mapped_type const & type is null", 0);
    return ;
  } 
  
  try {
    std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__setitem(arg1,(std::string const &)*arg2,(RobotRaconteur::ServiceSubscriptionFilterAttribute const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionattribute_ContainsKey(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >::key_type *arg2 = 0 ;
  bool result;
  
  arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >::key_type arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (bool)std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__ContainsKey(arg1,(std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionattribute_Add(void * jarg1, char * jarg2, void * jarg3) {
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >::key_type *arg2 = 0 ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >::mapped_type *arg3 = 0 ;
  
  arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >::key_type arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >::mapped_type *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >::mapped_type const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__Add(arg1,(std::string const &)*arg2,(RobotRaconteur::ServiceSubscriptionFilterAttribute const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionattribute_Remove(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >::key_type *arg2 = 0 ;
  bool result;
  
  arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >::key_type arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (bool)std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__Remove(arg1,(std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionattribute_create_iterator_begin(void * jarg1) {
  void * jresult ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute,std::less< std::string > >::iterator *result = 0 ;
  
  arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1; 
  
  try {
    result = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute,std::less< std::string > >::iterator *)std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__create_iterator_begin(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionattribute_get_next_key(void * jarg1, void * jarg2) {
  char * jresult ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute,std::less< std::string > >::iterator *arg2 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute,std::less< std::string > >::iterator *) 0 ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >::key_type *result = 0 ;
  
  arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1; 
  arg2 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute,std::less< std::string > >::iterator *)jarg2; 
  
  try {
    result = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute >::key_type *) &std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__get_next_key(arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionattribute_destroy_iterator(void * jarg1, void * jarg2) {
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute,std::less< std::string > >::iterator *arg2 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute,std::less< std::string > >::iterator *) 0 ;
  
  arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1; 
  arg2 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute,std::less< std::string > >::iterator *)jarg2; 
  
  try {
    std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttribute_Sg__destroy_iterator(arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_map_subscriptionattribute(void * jarg1) {
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  
  arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceSubscriptionFilterAttributeGroup_Attributes_set(void * jarg1, void * jarg2) {
  RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *) 0 ;
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *arg2 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *) 0 ;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *)jarg1; 
  arg2 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg2; 
  if (arg1) (arg1)->Attributes = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServiceSubscriptionFilterAttributeGroup_Attributes_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *) 0 ;
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *result = 0 ;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *)jarg1; 
  result = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *)& ((arg1)->Attributes);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceSubscriptionFilterAttributeGroup_Groups_set(void * jarg1, void * jarg2) {
  RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *) 0 ;
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *arg2 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *) 0 ;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *)jarg1; 
  arg2 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *)jarg2; 
  if (arg1) (arg1)->Groups = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_ServiceSubscriptionFilterAttributeGroup_Groups_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *) 0 ;
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *result = 0 ;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *)jarg1; 
  result = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *)& ((arg1)->Groups);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceSubscriptionFilterAttributeGroup_Operation_set(void * jarg1, int jarg2) {
  RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *) 0 ;
  RobotRaconteur::ServiceSubscriptionFilterAttributeGroupOperation arg2 ;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *)jarg1; 
  arg2 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroupOperation)jarg2; 
  if (arg1) (arg1)->Operation = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_ServiceSubscriptionFilterAttributeGroup_Operation_get(void * jarg1) {
  int jresult ;
  RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *) 0 ;
  RobotRaconteur::ServiceSubscriptionFilterAttributeGroupOperation result;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *)jarg1; 
  result = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroupOperation) ((arg1)->Operation);
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceSubscriptionFilterAttributeGroup_SplitStringAttribute_set(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *) 0 ;
  bool arg2 ;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *)jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->SplitStringAttribute = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_ServiceSubscriptionFilterAttributeGroup_SplitStringAttribute_get(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *) 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *)jarg1; 
  result = (bool) ((arg1)->SplitStringAttribute);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ServiceSubscriptionFilterAttributeGroup_SplitStringDelimiter_set(void * jarg1, char jarg2) {
  RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *) 0 ;
  char arg2 ;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *)jarg1; 
  arg2 = (char)jarg2; 
  if (arg1) (arg1)->SplitStringDelimiter = arg2;
}


SWIGEXPORT char SWIGSTDCALL CSharp_RobotRaconteur_ServiceSubscriptionFilterAttributeGroup_SplitStringDelimiter_get(void * jarg1) {
  char jresult ;
  RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *) 0 ;
  char result;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *)jarg1; 
  result = (char) ((arg1)->SplitStringDelimiter);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_ServiceSubscriptionFilterAttributeGroup__SWIG_0() {
  void * jresult ;
  RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *)new RobotRaconteur::ServiceSubscriptionFilterAttributeGroup();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_ServiceSubscriptionFilterAttributeGroup__SWIG_1(int jarg1) {
  void * jresult ;
  RobotRaconteur::ServiceSubscriptionFilterAttributeGroupOperation arg1 ;
  RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *result = 0 ;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroupOperation)jarg1; 
  
  try {
    result = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *)new RobotRaconteur::ServiceSubscriptionFilterAttributeGroup(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_ServiceSubscriptionFilterAttributeGroup__SWIG_2(int jarg1, void * jarg2) {
  void * jresult ;
  RobotRaconteur::ServiceSubscriptionFilterAttributeGroupOperation arg1 ;
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > arg2 ;
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *argp2 ;
  RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *result = 0 ;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroupOperation)jarg1; 
  argp2 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< RobotRaconteur::ServiceSubscriptionFilterAttribute >", 0);
    return 0;
  }
  arg2 = *argp2; 
  
  try {
    result = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *)new RobotRaconteur::ServiceSubscriptionFilterAttributeGroup(arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_ServiceSubscriptionFilterAttributeGroup__SWIG_3(int jarg1, void * jarg2) {
  void * jresult ;
  RobotRaconteur::ServiceSubscriptionFilterAttributeGroupOperation arg1 ;
  SwigValueWrapper< std::vector< RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > > arg2 ;
  std::vector< RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *argp2 ;
  RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *result = 0 ;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroupOperation)jarg1; 
  argp2 = (std::vector< RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >", 0);
    return 0;
  }
  arg2 = *argp2; 
  
  try {
    result = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *)new RobotRaconteur::ServiceSubscriptionFilterAttributeGroup(arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_ServiceSubscriptionFilterAttributeGroup_IsMatch__SWIG_0(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *) 0 ;
  std::string *arg2 = 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (bool)((RobotRaconteur::ServiceSubscriptionFilterAttributeGroup const *)arg1)->IsMatch((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_ServiceSubscriptionFilterAttributeGroup_IsMatch__SWIG_1(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *)jarg1; 
  arg2 = (std::vector< std::string > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)((RobotRaconteur::ServiceSubscriptionFilterAttributeGroup const *)arg1)->IsMatch((std::vector< std::string > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_ServiceSubscriptionFilterAttributeGroup_IsMatch__SWIG_2(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *) 0 ;
  std::map< std::string,std::string,std::less< std::string > > *arg2 = 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *)jarg1; 
  arg2 = (std::map< std::string,std::string,std::less< std::string > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< std::string,std::string,std::less< std::string > > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)((RobotRaconteur::ServiceSubscriptionFilterAttributeGroup const *)arg1)->IsMatch((std::map< std::string,std::string,std::less< std::string > > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_ServiceSubscriptionFilterAttributeGroup(void * jarg1) {
  RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *) 0 ;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroup *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_map_subscriptionattributegroup__SWIG_0() {
  void * jresult ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *result = 0 ;
  
  
  try {
    result = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *)new std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_map_subscriptionattributegroup__SWIG_1(void * jarg1) {
  void * jresult ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *arg1 = 0 ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *result = 0 ;
  
  arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *)new std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >((std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionattributegroup_size(void * jarg1) {
  unsigned long jresult ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *) 0 ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >::size_type result;
  
  arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *)jarg1; 
  
  try {
    result = ((std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > const *)arg1)->size();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionattributegroup_empty(void * jarg1) {
  unsigned int jresult ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *) 0 ;
  bool result;
  
  arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *)jarg1; 
  
  try {
    result = (bool)((std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > const *)arg1)->empty();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionattributegroup_Clear(void * jarg1) {
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *) 0 ;
  
  arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *)jarg1; 
  
  try {
    (arg1)->clear();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionattributegroup_getitem(void * jarg1, char * jarg2) {
  void * jresult ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *) 0 ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >::key_type *arg2 = 0 ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >::mapped_type *result = 0 ;
  
  arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >::key_type arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    try {
      result = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >::mapped_type *) &std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttributeGroup_Sg__getitem(arg1,(std::string const &)*arg2);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return 0;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionattributegroup_setitem(void * jarg1, char * jarg2, void * jarg3) {
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *) 0 ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >::key_type *arg2 = 0 ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >::mapped_type *arg3 = 0 ;
  
  arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >::key_type arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >::mapped_type *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >::mapped_type const & type is null", 0);
    return ;
  } 
  
  try {
    std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttributeGroup_Sg__setitem(arg1,(std::string const &)*arg2,(RobotRaconteur::ServiceSubscriptionFilterAttributeGroup const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionattributegroup_ContainsKey(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *) 0 ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >::key_type *arg2 = 0 ;
  bool result;
  
  arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >::key_type arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (bool)std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttributeGroup_Sg__ContainsKey(arg1,(std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionattributegroup_Add(void * jarg1, char * jarg2, void * jarg3) {
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *) 0 ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >::key_type *arg2 = 0 ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >::mapped_type *arg3 = 0 ;
  
  arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >::key_type arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >::mapped_type *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >::mapped_type const & type is null", 0);
    return ;
  } 
  
  try {
    try {
      std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttributeGroup_Sg__Add(arg1,(std::string const &)*arg2,(RobotRaconteur::ServiceSubscriptionFilterAttributeGroup const &)*arg3);
    } catch(std::out_of_range &_e) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
      return ;
    }
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionattributegroup_Remove(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *) 0 ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >::key_type *arg2 = 0 ;
  bool result;
  
  arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >::key_type arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (bool)std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttributeGroup_Sg__Remove(arg1,(std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionattributegroup_create_iterator_begin(void * jarg1) {
  void * jresult ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *) 0 ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup,std::less< std::string > >::iterator *result = 0 ;
  
  arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *)jarg1; 
  
  try {
    result = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup,std::less< std::string > >::iterator *)std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttributeGroup_Sg__create_iterator_begin(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionattributegroup_get_next_key(void * jarg1, void * jarg2) {
  char * jresult ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *) 0 ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup,std::less< std::string > >::iterator *arg2 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup,std::less< std::string > >::iterator *) 0 ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >::key_type *result = 0 ;
  
  arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *)jarg1; 
  arg2 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup,std::less< std::string > >::iterator *)jarg2; 
  
  try {
    result = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup >::key_type *) &std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttributeGroup_Sg__get_next_key(arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_map_subscriptionattributegroup_destroy_iterator(void * jarg1, void * jarg2) {
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *) 0 ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup,std::less< std::string > >::iterator *arg2 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup,std::less< std::string > >::iterator *) 0 ;
  
  arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *)jarg1; 
  arg2 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup,std::less< std::string > >::iterator *)jarg2; 
  
  try {
    std_map_Sl_std_string_Sc_RobotRaconteur_ServiceSubscriptionFilterAttributeGroup_Sg__destroy_iterator(arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_map_subscriptionattributegroup(void * jarg1) {
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *) 0 ;
  
  arg1 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup > *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionFilterPredicateDirector_Predicate(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::WrappedServiceSubscriptionFilterPredicateDirector *arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilterPredicateDirector *) 0 ;
  RobotRaconteur::ServiceInfo2Wrapped *arg2 = 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilterPredicateDirector *)jarg1; 
  arg2 = (RobotRaconteur::ServiceInfo2Wrapped *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::ServiceInfo2Wrapped const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)(arg1)->Predicate((RobotRaconteur::ServiceInfo2Wrapped const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedServiceSubscriptionFilterPredicateDirector(void * jarg1) {
  RobotRaconteur::WrappedServiceSubscriptionFilterPredicateDirector *arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilterPredicateDirector *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilterPredicateDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedServiceSubscriptionFilterPredicateDirector() {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscriptionFilterPredicateDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedServiceSubscriptionFilterPredicateDirector *)new SwigDirector_WrappedServiceSubscriptionFilterPredicateDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionFilterPredicateDirector_director_connect(void *objarg, SwigDirector_WrappedServiceSubscriptionFilterPredicateDirector::SWIG_Callback0_t callback0) {
  RobotRaconteur::WrappedServiceSubscriptionFilterPredicateDirector *obj = (RobotRaconteur::WrappedServiceSubscriptionFilterPredicateDirector *)objarg;
  SwigDirector_WrappedServiceSubscriptionFilterPredicateDirector *director = static_cast<SwigDirector_WrappedServiceSubscriptionFilterPredicateDirector *>(obj);
  director->swig_connect_director(callback0);
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionFilterNode_NodeID_set(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedServiceSubscriptionFilterNode *arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilterNode *) 0 ;
  ::RobotRaconteur::NodeID *arg2 = (::RobotRaconteur::NodeID *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionFilterNode > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilterNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (::RobotRaconteur::NodeID *)jarg2; 
  if (arg1) (arg1)->NodeID = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionFilterNode_NodeID_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscriptionFilterNode *arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilterNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > *smartarg1 = 0 ;
  ::RobotRaconteur::NodeID *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionFilterNode > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilterNode *)(smartarg1 ? smartarg1->get() : 0); 
  result = (::RobotRaconteur::NodeID *)& ((arg1)->NodeID);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionFilterNode_NodeName_set(void * jarg1, char * jarg2) {
  RobotRaconteur::WrappedServiceSubscriptionFilterNode *arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilterNode *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionFilterNode > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilterNode *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->NodeName = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionFilterNode_NodeName_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::WrappedServiceSubscriptionFilterNode *arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilterNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > *smartarg1 = 0 ;
  std::string *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionFilterNode > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilterNode *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::string *) & ((arg1)->NodeName);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Username_set(void * jarg1, char * jarg2) {
  RobotRaconteur::WrappedServiceSubscriptionFilterNode *arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilterNode *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionFilterNode > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilterNode *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->Username = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Username_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::WrappedServiceSubscriptionFilterNode *arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilterNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > *smartarg1 = 0 ;
  std::string *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionFilterNode > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilterNode *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::string *) & ((arg1)->Username);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Credentials_set(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedServiceSubscriptionFilterNode *arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilterNode *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > temp2 ;
  boost::shared_ptr< RobotRaconteur::MessageElementData > *smartarg2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionFilterNode > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilterNode *)(smartarg1 ? smartarg1->get() : 0); 
  
  // intrusive_ptr by reference
  if ( jarg2 ) {
    smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElementData >**)&jarg2;
    temp2 = boost::intrusive_ptr<  RobotRaconteur::MessageElementData >(smartarg2->get(), true);
    arg2 = &temp2;
  } else {
    arg2 = &tempnull2;
  }
  
  if (arg1) (arg1)->Credentials = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionFilterNode_Credentials_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscriptionFilterNode *arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilterNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionFilterNode > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilterNode *)(smartarg1 ? smartarg1->get() : 0); 
  result = (boost::intrusive_ptr< RobotRaconteur::MessageElementData > *) & ((arg1)->Credentials);
  
  if (*result) {
    intrusive_ptr_add_ref(result->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElementData > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElementData >(result->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElementData >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElementData > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedServiceSubscriptionFilterNode() {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscriptionFilterNode *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedServiceSubscriptionFilterNode *)new RobotRaconteur::WrappedServiceSubscriptionFilterNode();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionFilterNode >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedServiceSubscriptionFilterNode(void * jarg1) {
  RobotRaconteur::WrappedServiceSubscriptionFilterNode *arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilterNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionFilterNode > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilterNode *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionFilter_Nodes_set(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedServiceSubscriptionFilter *arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilter *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionFilter > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilter *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *)jarg2; 
  if (arg1) (arg1)->Nodes = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionFilter_Nodes_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscriptionFilter *arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilter *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > *smartarg1 = 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionFilter > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilter *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::vector< boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilterNode > > *)& ((arg1)->Nodes);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionFilter_ServiceNames_set(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedServiceSubscriptionFilter *arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilter *) 0 ;
  std::vector< std::string > *arg2 = (std::vector< std::string > *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionFilter > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilter *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< std::string > *)jarg2; 
  if (arg1) (arg1)->ServiceNames = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionFilter_ServiceNames_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscriptionFilter *arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilter *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > *smartarg1 = 0 ;
  std::vector< std::string > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionFilter > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilter *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::vector< std::string > *)& ((arg1)->ServiceNames);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionFilter_TransportSchemes_set(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedServiceSubscriptionFilter *arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilter *) 0 ;
  std::vector< std::string > *arg2 = (std::vector< std::string > *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionFilter > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilter *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< std::string > *)jarg2; 
  if (arg1) (arg1)->TransportSchemes = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionFilter_TransportSchemes_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscriptionFilter *arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilter *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > *smartarg1 = 0 ;
  std::vector< std::string > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionFilter > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilter *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::vector< std::string > *)& ((arg1)->TransportSchemes);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionFilter_Attributes_set(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedServiceSubscriptionFilter *arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilter *) 0 ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup,std::less< std::string > > *arg2 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup,std::less< std::string > > *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionFilter > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilter *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup,std::less< std::string > > *)jarg2; 
  if (arg1) (arg1)->Attributes = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionFilter_Attributes_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscriptionFilter *arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilter *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > *smartarg1 = 0 ;
  std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup,std::less< std::string > > *result = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionFilter > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilter *)(smartarg1 ? smartarg1->get() : 0); 
  result = (std::map< std::string,RobotRaconteur::ServiceSubscriptionFilterAttributeGroup,std::less< std::string > > *)& ((arg1)->Attributes);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionFilter_AttributesMatchOperation_set(void * jarg1, int jarg2) {
  RobotRaconteur::WrappedServiceSubscriptionFilter *arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilter *) 0 ;
  RobotRaconteur::ServiceSubscriptionFilterAttributeGroupOperation arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionFilter > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilter *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroupOperation)jarg2; 
  if (arg1) (arg1)->AttributesMatchOperation = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionFilter_AttributesMatchOperation_get(void * jarg1) {
  int jresult ;
  RobotRaconteur::WrappedServiceSubscriptionFilter *arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilter *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > *smartarg1 = 0 ;
  RobotRaconteur::ServiceSubscriptionFilterAttributeGroupOperation result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionFilter > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilter *)(smartarg1 ? smartarg1->get() : 0); 
  result = (RobotRaconteur::ServiceSubscriptionFilterAttributeGroupOperation) ((arg1)->AttributesMatchOperation);
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionFilter_SetRRPredicateDirector(void * jarg1, void * jarg2, int jarg3) {
  RobotRaconteur::WrappedServiceSubscriptionFilter *arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilter *) 0 ;
  RobotRaconteur::WrappedServiceSubscriptionFilterPredicateDirector *arg2 = (RobotRaconteur::WrappedServiceSubscriptionFilterPredicateDirector *) 0 ;
  int32_t arg3 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionFilter > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilter *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::WrappedServiceSubscriptionFilterPredicateDirector *)jarg2; 
  arg3 = (int32_t)jarg3; 
  
  try {
    (arg1)->SetRRPredicateDirector(arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionFilter_MaxConnections_set(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::WrappedServiceSubscriptionFilter *arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilter *) 0 ;
  uint32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionFilter > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilter *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (uint32_t)jarg2; 
  if (arg1) (arg1)->MaxConnections = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionFilter_MaxConnections_get(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::WrappedServiceSubscriptionFilter *arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilter *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > *smartarg1 = 0 ;
  uint32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionFilter > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilter *)(smartarg1 ? smartarg1->get() : 0); 
  result = (uint32_t) ((arg1)->MaxConnections);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedServiceSubscriptionFilter() {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscriptionFilter *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedServiceSubscriptionFilter *)new RobotRaconteur::WrappedServiceSubscriptionFilter();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionFilter >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedServiceSubscriptionFilter(void * jarg1) {
  RobotRaconteur::WrappedServiceSubscriptionFilter *arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilter *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionFilter > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionFilter *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionClientID_NodeID_set(void * jarg1, void * jarg2) {
  RobotRaconteur::ServiceSubscriptionClientID *arg1 = (RobotRaconteur::ServiceSubscriptionClientID *) 0 ;
  ::RobotRaconteur::NodeID *arg2 = (::RobotRaconteur::NodeID *) 0 ;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionClientID *)jarg1; 
  arg2 = (::RobotRaconteur::NodeID *)jarg2; 
  if (arg1) (arg1)->NodeID = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionClientID_NodeID_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::ServiceSubscriptionClientID *arg1 = (RobotRaconteur::ServiceSubscriptionClientID *) 0 ;
  ::RobotRaconteur::NodeID *result = 0 ;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionClientID *)jarg1; 
  result = (::RobotRaconteur::NodeID *)& ((arg1)->NodeID);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionClientID_ServiceName_set(void * jarg1, char * jarg2) {
  RobotRaconteur::ServiceSubscriptionClientID *arg1 = (RobotRaconteur::ServiceSubscriptionClientID *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionClientID *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->ServiceName = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionClientID_ServiceName_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::ServiceSubscriptionClientID *arg1 = (RobotRaconteur::ServiceSubscriptionClientID *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionClientID *)jarg1; 
  result = (std::string *) & ((arg1)->ServiceName);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionClientID_eq(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::ServiceSubscriptionClientID *arg1 = (RobotRaconteur::ServiceSubscriptionClientID *) 0 ;
  RobotRaconteur::ServiceSubscriptionClientID *arg2 = 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionClientID *)jarg1; 
  arg2 = (RobotRaconteur::ServiceSubscriptionClientID *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::ServiceSubscriptionClientID const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)((RobotRaconteur::ServiceSubscriptionClientID const *)arg1)->operator ==((RobotRaconteur::ServiceSubscriptionClientID const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionClientID_ne(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::ServiceSubscriptionClientID *arg1 = (RobotRaconteur::ServiceSubscriptionClientID *) 0 ;
  RobotRaconteur::ServiceSubscriptionClientID *arg2 = 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionClientID *)jarg1; 
  arg2 = (RobotRaconteur::ServiceSubscriptionClientID *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::ServiceSubscriptionClientID const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)((RobotRaconteur::ServiceSubscriptionClientID const *)arg1)->operator !=((RobotRaconteur::ServiceSubscriptionClientID const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedServiceSubscriptionClientID(void * jarg1) {
  RobotRaconteur::ServiceSubscriptionClientID *arg1 = (RobotRaconteur::ServiceSubscriptionClientID *) 0 ;
  
  arg1 = (RobotRaconteur::ServiceSubscriptionClientID *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceInfo2SubscriptionDirector_ServiceDetected(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  RobotRaconteur::WrappedServiceInfo2SubscriptionDirector *arg1 = (RobotRaconteur::WrappedServiceInfo2SubscriptionDirector *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceInfo2Subscription > *arg2 = 0 ;
  RobotRaconteur::ServiceSubscriptionClientID *arg3 = 0 ;
  RobotRaconteur::ServiceInfo2Wrapped *arg4 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceInfo2Subscription > tempnull2 ;
  
  arg1 = (RobotRaconteur::WrappedServiceInfo2SubscriptionDirector *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceInfo2Subscription > *)jarg2 : &tempnull2; 
  arg3 = (RobotRaconteur::ServiceSubscriptionClientID *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::ServiceSubscriptionClientID const & type is null", 0);
    return ;
  } 
  arg4 = (RobotRaconteur::ServiceInfo2Wrapped *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::ServiceInfo2Wrapped const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->ServiceDetected((boost::shared_ptr< RobotRaconteur::WrappedServiceInfo2Subscription > const &)*arg2,(RobotRaconteur::ServiceSubscriptionClientID const &)*arg3,(RobotRaconteur::ServiceInfo2Wrapped const &)*arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceInfo2SubscriptionDirector_ServiceLost(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  RobotRaconteur::WrappedServiceInfo2SubscriptionDirector *arg1 = (RobotRaconteur::WrappedServiceInfo2SubscriptionDirector *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceInfo2Subscription > *arg2 = 0 ;
  RobotRaconteur::ServiceSubscriptionClientID *arg3 = 0 ;
  RobotRaconteur::ServiceInfo2Wrapped *arg4 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceInfo2Subscription > tempnull2 ;
  
  arg1 = (RobotRaconteur::WrappedServiceInfo2SubscriptionDirector *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceInfo2Subscription > *)jarg2 : &tempnull2; 
  arg3 = (RobotRaconteur::ServiceSubscriptionClientID *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::ServiceSubscriptionClientID const & type is null", 0);
    return ;
  } 
  arg4 = (RobotRaconteur::ServiceInfo2Wrapped *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::ServiceInfo2Wrapped const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->ServiceLost((boost::shared_ptr< RobotRaconteur::WrappedServiceInfo2Subscription > const &)*arg2,(RobotRaconteur::ServiceSubscriptionClientID const &)*arg3,(RobotRaconteur::ServiceInfo2Wrapped const &)*arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedServiceInfo2SubscriptionDirector(void * jarg1) {
  RobotRaconteur::WrappedServiceInfo2SubscriptionDirector *arg1 = (RobotRaconteur::WrappedServiceInfo2SubscriptionDirector *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedServiceInfo2SubscriptionDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedServiceInfo2SubscriptionDirector() {
  void * jresult ;
  RobotRaconteur::WrappedServiceInfo2SubscriptionDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedServiceInfo2SubscriptionDirector *)new SwigDirector_WrappedServiceInfo2SubscriptionDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceInfo2SubscriptionDirector_director_connect(void *objarg, SwigDirector_WrappedServiceInfo2SubscriptionDirector::SWIG_Callback0_t callback0, SwigDirector_WrappedServiceInfo2SubscriptionDirector::SWIG_Callback1_t callback1) {
  RobotRaconteur::WrappedServiceInfo2SubscriptionDirector *obj = (RobotRaconteur::WrappedServiceInfo2SubscriptionDirector *)objarg;
  SwigDirector_WrappedServiceInfo2SubscriptionDirector *director = static_cast<SwigDirector_WrappedServiceInfo2SubscriptionDirector *>(obj);
  director->swig_connect_director(callback0, callback1);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceInfo2Subscription_GetDetectedServiceInfo2(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedServiceInfo2Subscription *arg1 = (RobotRaconteur::WrappedServiceInfo2Subscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceInfo2Subscription > *smartarg1 = 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped,std::less< RobotRaconteur::ServiceSubscriptionClientID > > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceInfo2Subscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceInfo2Subscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetDetectedServiceInfo2();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped,std::less< RobotRaconteur::ServiceSubscriptionClientID > >((const std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped,std::less< RobotRaconteur::ServiceSubscriptionClientID > > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceInfo2Subscription_Close(void * jarg1) {
  RobotRaconteur::WrappedServiceInfo2Subscription *arg1 = (RobotRaconteur::WrappedServiceInfo2Subscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceInfo2Subscription > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceInfo2Subscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceInfo2Subscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->Close();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceInfo2Subscription_SetRRDirector(void * jarg1, void * jarg2, int jarg3) {
  RobotRaconteur::WrappedServiceInfo2Subscription *arg1 = (RobotRaconteur::WrappedServiceInfo2Subscription *) 0 ;
  RobotRaconteur::WrappedServiceInfo2SubscriptionDirector *arg2 = (RobotRaconteur::WrappedServiceInfo2SubscriptionDirector *) 0 ;
  int32_t arg3 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceInfo2Subscription > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceInfo2Subscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceInfo2Subscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::WrappedServiceInfo2SubscriptionDirector *)jarg2; 
  arg3 = (int32_t)jarg3; 
  
  try {
    (arg1)->SetRRDirector(arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceInfo2Subscription_GetNode(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedServiceInfo2Subscription *arg1 = (RobotRaconteur::WrappedServiceInfo2Subscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceInfo2Subscription > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceInfo2Subscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceInfo2Subscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetNode();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::RobotRaconteurNode >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedServiceInfo2Subscription(void * jarg1) {
  RobotRaconteur::WrappedServiceInfo2Subscription *arg1 = (RobotRaconteur::WrappedServiceInfo2Subscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceInfo2Subscription > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceInfo2Subscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceInfo2Subscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionDirector_ClientConnected(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  RobotRaconteur::WrappedServiceSubscriptionDirector *arg1 = (RobotRaconteur::WrappedServiceSubscriptionDirector *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *arg2 = 0 ;
  RobotRaconteur::ServiceSubscriptionClientID *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *arg4 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > tempnull2 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > tempnull4 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionDirector *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *)jarg2 : &tempnull2; 
  arg3 = (RobotRaconteur::ServiceSubscriptionClientID *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::ServiceSubscriptionClientID const & type is null", 0);
    return ;
  } 
  arg4 = jarg4 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *)jarg4 : &tempnull4; 
  
  try {
    (arg1)->ClientConnected((boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > const &)*arg2,(RobotRaconteur::ServiceSubscriptionClientID const &)*arg3,(boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &)*arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionDirector_ClientDisconnected(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  RobotRaconteur::WrappedServiceSubscriptionDirector *arg1 = (RobotRaconteur::WrappedServiceSubscriptionDirector *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *arg2 = 0 ;
  RobotRaconteur::ServiceSubscriptionClientID *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *arg4 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > tempnull2 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > tempnull4 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionDirector *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *)jarg2 : &tempnull2; 
  arg3 = (RobotRaconteur::ServiceSubscriptionClientID *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::ServiceSubscriptionClientID const & type is null", 0);
    return ;
  } 
  arg4 = jarg4 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *)jarg4 : &tempnull4; 
  
  try {
    (arg1)->ClientDisconnected((boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > const &)*arg2,(RobotRaconteur::ServiceSubscriptionClientID const &)*arg3,(boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &)*arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionDirector_ClientConnectFailed(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  RobotRaconteur::WrappedServiceSubscriptionDirector *arg1 = (RobotRaconteur::WrappedServiceSubscriptionDirector *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *arg2 = 0 ;
  RobotRaconteur::ServiceSubscriptionClientID *arg3 = 0 ;
  std::vector< std::string > *arg4 = 0 ;
  RobotRaconteur::HandlerErrorInfo *arg5 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > tempnull2 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionDirector *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *)jarg2 : &tempnull2; 
  arg3 = (RobotRaconteur::ServiceSubscriptionClientID *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::ServiceSubscriptionClientID const & type is null", 0);
    return ;
  } 
  arg4 = (std::vector< std::string > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return ;
  } 
  arg5 = (RobotRaconteur::HandlerErrorInfo *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::HandlerErrorInfo & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->ClientConnectFailed((boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > const &)*arg2,(RobotRaconteur::ServiceSubscriptionClientID const &)*arg3,(std::vector< std::string > const &)*arg4,*arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedServiceSubscriptionDirector(void * jarg1) {
  RobotRaconteur::WrappedServiceSubscriptionDirector *arg1 = (RobotRaconteur::WrappedServiceSubscriptionDirector *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedServiceSubscriptionDirector() {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscriptionDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedServiceSubscriptionDirector *)new SwigDirector_WrappedServiceSubscriptionDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionDirector_director_connect(void *objarg, SwigDirector_WrappedServiceSubscriptionDirector::SWIG_Callback0_t callback0, SwigDirector_WrappedServiceSubscriptionDirector::SWIG_Callback1_t callback1, SwigDirector_WrappedServiceSubscriptionDirector::SWIG_Callback2_t callback2) {
  RobotRaconteur::WrappedServiceSubscriptionDirector *obj = (RobotRaconteur::WrappedServiceSubscriptionDirector *)objarg;
  SwigDirector_WrappedServiceSubscriptionDirector *director = static_cast<SwigDirector_WrappedServiceSubscriptionDirector *>(obj);
  director->swig_connect_director(callback0, callback1, callback2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_TryDefaultClientRes_res_set(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes *arg1 = (RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes *) 0 ;
  bool arg2 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes *)jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->res = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_TryDefaultClientRes_res_get(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes *arg1 = (RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes *) 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes *)jarg1; 
  result = (bool) ((arg1)->res);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_TryDefaultClientRes_client_set(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes *arg1 = (RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > tempnull2 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *)jarg2 : &tempnull2; 
  if (arg1) (arg1)->client = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_TryDefaultClientRes_client_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes *arg1 = (RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *result = 0 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes *)jarg1; 
  result = (boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *) & ((arg1)->client);
  jresult = *result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceStub >(*result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedServiceSubscription_TryDefaultClientRes() {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes *)new RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedServiceSubscription_TryDefaultClientRes(void * jarg1) {
  RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes *arg1 = (RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_GetConnectedClients(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub >,std::less< RobotRaconteur::ServiceSubscriptionClientID > > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetConnectedClients();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub >,std::less< RobotRaconteur::ServiceSubscriptionClientID > >((const std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub >,std::less< RobotRaconteur::ServiceSubscriptionClientID > > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_Close(void * jarg1) {
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->Close();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_ClaimClient(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *)jarg2 : &tempnull2; 
  
  try {
    (arg1)->ClaimClient((boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_ReleaseClient(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *)jarg2 : &tempnull2; 
  
  try {
    (arg1)->ReleaseClient((boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_GetConnectRetryDelay(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  uint32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (uint32_t)(arg1)->GetConnectRetryDelay();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_SetConnectRetryDelay(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  uint32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (uint32_t)jarg2; 
  
  try {
    (arg1)->SetConnectRetryDelay(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_SubscribeWire(void * jarg1, char * jarg2, char * jarg3) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireSubscription > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  try {
    result = (arg1)->SubscribeWire((std::string const &)*arg2,(std::string const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedWireSubscription >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_SubscribePipe__SWIG_0(void * jarg1, char * jarg2, char * jarg3, int jarg4) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  int32_t arg4 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeSubscription > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  arg4 = (int32_t)jarg4; 
  
  try {
    result = (arg1)->SubscribePipe((std::string const &)*arg2,(std::string const &)*arg3,arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedPipeSubscription >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_SubscribePipe__SWIG_1(void * jarg1, char * jarg2, char * jarg3) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeSubscription > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  try {
    result = (arg1)->SubscribePipe((std::string const &)*arg2,(std::string const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedPipeSubscription >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_GetDefaultClient(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetDefaultClient();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceStub >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_TryGetDefaultClient(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->TryGetDefaultClient();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes((const RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_GetDefaultClientWait__SWIG_0(void * jarg1, int jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  int32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  
  try {
    result = (arg1)->GetDefaultClientWait(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceStub >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_GetDefaultClientWait__SWIG_1(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetDefaultClientWait();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceStub >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_TryGetDefaultClientWait__SWIG_0(void * jarg1, int jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  int32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  
  try {
    result = (arg1)->TryGetDefaultClientWait(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes((const RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_TryGetDefaultClientWait__SWIG_1(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->TryGetDefaultClientWait();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes((const RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_AsyncGetDefaultClient(void * jarg1, int jarg2, void * jarg3, int jarg4) {
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  int32_t arg2 ;
  RobotRaconteur::AsyncStubReturnDirector *arg3 = (RobotRaconteur::AsyncStubReturnDirector *) 0 ;
  int32_t arg4 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  arg3 = (RobotRaconteur::AsyncStubReturnDirector *)jarg3; 
  arg4 = (int32_t)jarg4; 
  
  try {
    (arg1)->AsyncGetDefaultClient(arg2,arg3,arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_SetRRDirector(void * jarg1, void * jarg2, int jarg3) {
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  RobotRaconteur::WrappedServiceSubscriptionDirector *arg2 = (RobotRaconteur::WrappedServiceSubscriptionDirector *) 0 ;
  int32_t arg3 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::WrappedServiceSubscriptionDirector *)jarg2; 
  arg3 = (int32_t)jarg3; 
  
  try {
    (arg1)->SetRRDirector(arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_GetNode(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetNode();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::RobotRaconteurNode >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_GetServiceURL(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  std::vector< std::string > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetServiceURL();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< std::string >((const std::vector< std::string > &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_UpdateServiceURL__SWIG_0(void * jarg1, void * jarg2, char * jarg3, void * jarg4, char * jarg5, unsigned int jarg6) {
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > arg4 ;
  std::string *arg5 = 0 ;
  bool arg6 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementData > *smartarg4 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< std::string > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return ;
  } 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  // intrusive_ptr by value
  smartarg4 = *(boost::shared_ptr<  RobotRaconteur::MessageElementData >**)&jarg4;
  if (smartarg4) {
    arg4 = boost::intrusive_ptr<  RobotRaconteur::MessageElementData >(smartarg4->get(), true);
  }
  
  if (!jarg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg5_str(jarg5);
  arg5 = &arg5_str; 
  arg6 = jarg6 ? true : false; 
  
  try {
    (arg1)->UpdateServiceURL((std::vector< std::string > const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,arg6);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_UpdateServiceURL__SWIG_1(void * jarg1, void * jarg2, char * jarg3, void * jarg4, char * jarg5) {
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > arg4 ;
  std::string *arg5 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementData > *smartarg4 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< std::string > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return ;
  } 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  // intrusive_ptr by value
  smartarg4 = *(boost::shared_ptr<  RobotRaconteur::MessageElementData >**)&jarg4;
  if (smartarg4) {
    arg4 = boost::intrusive_ptr<  RobotRaconteur::MessageElementData >(smartarg4->get(), true);
  }
  
  if (!jarg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg5_str(jarg5);
  arg5 = &arg5_str; 
  
  try {
    (arg1)->UpdateServiceURL((std::vector< std::string > const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_UpdateServiceURL__SWIG_2(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > arg4 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementData > *smartarg4 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< std::string > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return ;
  } 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  // intrusive_ptr by value
  smartarg4 = *(boost::shared_ptr<  RobotRaconteur::MessageElementData >**)&jarg4;
  if (smartarg4) {
    arg4 = boost::intrusive_ptr<  RobotRaconteur::MessageElementData >(smartarg4->get(), true);
  }
  
  
  try {
    (arg1)->UpdateServiceURL((std::vector< std::string > const &)*arg2,(std::string const &)*arg3,arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_UpdateServiceURL__SWIG_3(void * jarg1, void * jarg2, char * jarg3) {
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< std::string > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return ;
  } 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  try {
    (arg1)->UpdateServiceURL((std::vector< std::string > const &)*arg2,(std::string const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_UpdateServiceURL__SWIG_4(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< std::string > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->UpdateServiceURL((std::vector< std::string > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_UpdateServiceURL__SWIG_5(void * jarg1, char * jarg2, char * jarg3, void * jarg4, char * jarg5, unsigned int jarg6) {
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > arg4 ;
  std::string *arg5 = 0 ;
  bool arg6 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementData > *smartarg4 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  // intrusive_ptr by value
  smartarg4 = *(boost::shared_ptr<  RobotRaconteur::MessageElementData >**)&jarg4;
  if (smartarg4) {
    arg4 = boost::intrusive_ptr<  RobotRaconteur::MessageElementData >(smartarg4->get(), true);
  }
  
  if (!jarg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg5_str(jarg5);
  arg5 = &arg5_str; 
  arg6 = jarg6 ? true : false; 
  
  try {
    (arg1)->UpdateServiceURL((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,arg6);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_UpdateServiceURL__SWIG_6(void * jarg1, char * jarg2, char * jarg3, void * jarg4, char * jarg5) {
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > arg4 ;
  std::string *arg5 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementData > *smartarg4 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  // intrusive_ptr by value
  smartarg4 = *(boost::shared_ptr<  RobotRaconteur::MessageElementData >**)&jarg4;
  if (smartarg4) {
    arg4 = boost::intrusive_ptr<  RobotRaconteur::MessageElementData >(smartarg4->get(), true);
  }
  
  if (!jarg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg5_str(jarg5);
  arg5 = &arg5_str; 
  
  try {
    (arg1)->UpdateServiceURL((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_UpdateServiceURL__SWIG_7(void * jarg1, char * jarg2, char * jarg3, void * jarg4) {
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > arg4 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementData > *smartarg4 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  // intrusive_ptr by value
  smartarg4 = *(boost::shared_ptr<  RobotRaconteur::MessageElementData >**)&jarg4;
  if (smartarg4) {
    arg4 = boost::intrusive_ptr<  RobotRaconteur::MessageElementData >(smartarg4->get(), true);
  }
  
  
  try {
    (arg1)->UpdateServiceURL((std::string const &)*arg2,(std::string const &)*arg3,arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_UpdateServiceURL__SWIG_8(void * jarg1, char * jarg2, char * jarg3) {
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  try {
    (arg1)->UpdateServiceURL((std::string const &)*arg2,(std::string const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_UpdateServiceURL__SWIG_9(void * jarg1, char * jarg2) {
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->UpdateServiceURL((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_UpdateServiceByType__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > tempnull3 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< std::string > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return ;
  } 
  arg3 = jarg3 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > *)jarg3 : &tempnull3; 
  
  try {
    (arg1)->UpdateServiceByType((std::vector< std::string > const &)*arg2,(boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_UpdateServiceByType__SWIG_1(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< std::string > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->UpdateServiceByType((std::vector< std::string > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_SubscribeSubObject__SWIG_0(void * jarg1, char * jarg2, char * jarg3) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedSubObjectSubscription > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  try {
    result = (arg1)->SubscribeSubObject((std::string const &)*arg2,(std::string const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedSubObjectSubscription >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscription_SubscribeSubObject__SWIG_1(void * jarg1, char * jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedSubObjectSubscription > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (arg1)->SubscribeSubObject((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedSubObjectSubscription >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedServiceSubscription(void * jarg1) {
  RobotRaconteur::WrappedServiceSubscription *arg1 = (RobotRaconteur::WrappedServiceSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireSubscriptionDirector_WireValueChanged(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  RobotRaconteur::WrappedWireSubscriptionDirector *arg1 = (RobotRaconteur::WrappedWireSubscriptionDirector *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireSubscription > *arg2 = 0 ;
  RobotRaconteur::WrappedService_typed_packet *arg3 = 0 ;
  RobotRaconteur::TimeSpec *arg4 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireSubscription > tempnull2 ;
  
  arg1 = (RobotRaconteur::WrappedWireSubscriptionDirector *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedWireSubscription > *)jarg2 : &tempnull2; 
  arg3 = (RobotRaconteur::WrappedService_typed_packet *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::WrappedService_typed_packet & type is null", 0);
    return ;
  } 
  arg4 = (RobotRaconteur::TimeSpec *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::TimeSpec const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->WireValueChanged((boost::shared_ptr< RobotRaconteur::WrappedWireSubscription > const &)*arg2,*arg3,(RobotRaconteur::TimeSpec const &)*arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedWireSubscriptionDirector(void * jarg1) {
  RobotRaconteur::WrappedWireSubscriptionDirector *arg1 = (RobotRaconteur::WrappedWireSubscriptionDirector *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedWireSubscriptionDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedWireSubscriptionDirector() {
  void * jresult ;
  RobotRaconteur::WrappedWireSubscriptionDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedWireSubscriptionDirector *)new SwigDirector_WrappedWireSubscriptionDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireSubscriptionDirector_director_connect(void *objarg, SwigDirector_WrappedWireSubscriptionDirector::SWIG_Callback0_t callback0) {
  RobotRaconteur::WrappedWireSubscriptionDirector *obj = (RobotRaconteur::WrappedWireSubscriptionDirector *)objarg;
  SwigDirector_WrappedWireSubscriptionDirector *director = static_cast<SwigDirector_WrappedWireSubscriptionDirector *>(obj);
  director->swig_connect_director(callback0);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireSubscription_GetInValue__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedWireSubscription *arg1 = (RobotRaconteur::WrappedWireSubscription *) 0 ;
  RobotRaconteur::TimeSpec *arg2 = (RobotRaconteur::TimeSpec *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireSubscription > *smartarg1 = 0 ;
  RobotRaconteur::WrappedService_typed_packet result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::TimeSpec *)jarg2; 
  
  try {
    result = (arg1)->GetInValue(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::WrappedService_typed_packet((const RobotRaconteur::WrappedService_typed_packet &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireSubscription_GetInValue__SWIG_1(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedWireSubscription *arg1 = (RobotRaconteur::WrappedWireSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireSubscription > *smartarg1 = 0 ;
  RobotRaconteur::WrappedService_typed_packet result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetInValue();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::WrappedService_typed_packet((const RobotRaconteur::WrappedService_typed_packet &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireSubscription_TryGetInValue__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
  unsigned int jresult ;
  RobotRaconteur::WrappedWireSubscription *arg1 = (RobotRaconteur::WrappedWireSubscription *) 0 ;
  RobotRaconteur::WrappedService_typed_packet *arg2 = 0 ;
  RobotRaconteur::TimeSpec *arg3 = (RobotRaconteur::TimeSpec *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireSubscription > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::WrappedService_typed_packet *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::WrappedService_typed_packet & type is null", 0);
    return 0;
  } 
  arg3 = (RobotRaconteur::TimeSpec *)jarg3; 
  
  try {
    result = (bool)(arg1)->TryGetInValue(*arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireSubscription_TryGetInValue__SWIG_1(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::WrappedWireSubscription *arg1 = (RobotRaconteur::WrappedWireSubscription *) 0 ;
  RobotRaconteur::WrappedService_typed_packet *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireSubscription > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::WrappedService_typed_packet *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::WrappedService_typed_packet & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)(arg1)->TryGetInValue(*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireSubscription_WaitInValueValid__SWIG_0(void * jarg1, int jarg2) {
  unsigned int jresult ;
  RobotRaconteur::WrappedWireSubscription *arg1 = (RobotRaconteur::WrappedWireSubscription *) 0 ;
  int32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireSubscription > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  
  try {
    result = (bool)(arg1)->WaitInValueValid(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireSubscription_WaitInValueValid__SWIG_1(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::WrappedWireSubscription *arg1 = (RobotRaconteur::WrappedWireSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireSubscription > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->WaitInValueValid();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireSubscription_GetIgnoreInValue(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::WrappedWireSubscription *arg1 = (RobotRaconteur::WrappedWireSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireSubscription > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->GetIgnoreInValue();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireSubscription_SetIgnoreInValue(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::WrappedWireSubscription *arg1 = (RobotRaconteur::WrappedWireSubscription *) 0 ;
  bool arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireSubscription > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? true : false; 
  
  try {
    (arg1)->SetIgnoreInValue(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireSubscription_GetInValueLifespan(void * jarg1) {
  int jresult ;
  RobotRaconteur::WrappedWireSubscription *arg1 = (RobotRaconteur::WrappedWireSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireSubscription > *smartarg1 = 0 ;
  int32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (int32_t)(arg1)->GetInValueLifespan();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireSubscription_SetInValueLifespan(void * jarg1, int jarg2) {
  RobotRaconteur::WrappedWireSubscription *arg1 = (RobotRaconteur::WrappedWireSubscription *) 0 ;
  int32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireSubscription > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  
  try {
    (arg1)->SetInValueLifespan(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireSubscription_GetActiveWireConnectionCount(void * jarg1) {
  unsigned long jresult ;
  RobotRaconteur::WrappedWireSubscription *arg1 = (RobotRaconteur::WrappedWireSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireSubscription > *smartarg1 = 0 ;
  size_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetActiveWireConnectionCount();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireSubscription_Close(void * jarg1) {
  RobotRaconteur::WrappedWireSubscription *arg1 = (RobotRaconteur::WrappedWireSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireSubscription > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->Close();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireSubscription_SetRRDirector(void * jarg1, void * jarg2, int jarg3) {
  RobotRaconteur::WrappedWireSubscription *arg1 = (RobotRaconteur::WrappedWireSubscription *) 0 ;
  RobotRaconteur::WrappedWireSubscriptionDirector *arg2 = (RobotRaconteur::WrappedWireSubscriptionDirector *) 0 ;
  int32_t arg3 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireSubscription > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::WrappedWireSubscriptionDirector *)jarg2; 
  arg3 = (int32_t)jarg3; 
  
  try {
    (arg1)->SetRRDirector(arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireSubscription_GetNode(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedWireSubscription *arg1 = (RobotRaconteur::WrappedWireSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireSubscription > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetNode();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::RobotRaconteurNode >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedWireSubscription(void * jarg1) {
  RobotRaconteur::WrappedWireSubscription *arg1 = (RobotRaconteur::WrappedWireSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireSubscription > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedWireSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedWireSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedWireSubscription_send_iterator(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::WrappedWireSubscription > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireSubscription > tempnull1 ;
  RobotRaconteur::WrappedWireSubscription_send_iterator *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::WrappedWireSubscription > *)jarg1 : &tempnull1; 
  
  try {
    result = (RobotRaconteur::WrappedWireSubscription_send_iterator *)new RobotRaconteur::WrappedWireSubscription_send_iterator((boost::shared_ptr< RobotRaconteur::WrappedWireSubscription > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireSubscription_send_iterator_Next(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedWireSubscription_send_iterator *arg1 = (RobotRaconteur::WrappedWireSubscription_send_iterator *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireConnection > result;
  
  arg1 = (RobotRaconteur::WrappedWireSubscription_send_iterator *)jarg1; 
  
  try {
    result = (arg1)->Next();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedWireConnection >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireSubscription_send_iterator_SetOutValue(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedWireSubscription_send_iterator *arg1 = (RobotRaconteur::WrappedWireSubscription_send_iterator *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *arg2 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > temp2 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg2 ;
  
  arg1 = (RobotRaconteur::WrappedWireSubscription_send_iterator *)jarg1; 
  
  // intrusive_ptr by reference
  if ( jarg2 ) {
    smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg2;
    temp2 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg2->get(), true);
    arg2 = &temp2;
  } else {
    arg2 = &tempnull2;
  }
  
  
  try {
    (arg1)->SetOutValue((boost::intrusive_ptr< RobotRaconteur::MessageElement > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireSubscription_send_iterator_GetType(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedWireSubscription_send_iterator *arg1 = (RobotRaconteur::WrappedWireSubscription_send_iterator *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > result;
  
  arg1 = (RobotRaconteur::WrappedWireSubscription_send_iterator *)jarg1; 
  
  try {
    result = (arg1)->GetType();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::TypeDefinition >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedWireSubscription_send_iterator_GetStub(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedWireSubscription_send_iterator *arg1 = (RobotRaconteur::WrappedWireSubscription_send_iterator *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > result;
  
  arg1 = (RobotRaconteur::WrappedWireSubscription_send_iterator *)jarg1; 
  
  try {
    result = (arg1)->GetStub();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceStub >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedWireSubscription_send_iterator(void * jarg1) {
  RobotRaconteur::WrappedWireSubscription_send_iterator *arg1 = (RobotRaconteur::WrappedWireSubscription_send_iterator *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedWireSubscription_send_iterator *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeSubscriptionDirector_PipePacketReceived(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedPipeSubscriptionDirector *arg1 = (RobotRaconteur::WrappedPipeSubscriptionDirector *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeSubscription > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeSubscription > tempnull2 ;
  
  arg1 = (RobotRaconteur::WrappedPipeSubscriptionDirector *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedPipeSubscription > *)jarg2 : &tempnull2; 
  
  try {
    (arg1)->PipePacketReceived((boost::shared_ptr< RobotRaconteur::WrappedPipeSubscription > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedPipeSubscriptionDirector(void * jarg1) {
  RobotRaconteur::WrappedPipeSubscriptionDirector *arg1 = (RobotRaconteur::WrappedPipeSubscriptionDirector *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedPipeSubscriptionDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedPipeSubscriptionDirector() {
  void * jresult ;
  RobotRaconteur::WrappedPipeSubscriptionDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedPipeSubscriptionDirector *)new SwigDirector_WrappedPipeSubscriptionDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeSubscriptionDirector_director_connect(void *objarg, SwigDirector_WrappedPipeSubscriptionDirector::SWIG_Callback0_t callback0) {
  RobotRaconteur::WrappedPipeSubscriptionDirector *obj = (RobotRaconteur::WrappedPipeSubscriptionDirector *)objarg;
  SwigDirector_WrappedPipeSubscriptionDirector *director = static_cast<SwigDirector_WrappedPipeSubscriptionDirector *>(obj);
  director->swig_connect_director(callback0);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeSubscription_ReceivePacket(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedPipeSubscription *arg1 = (RobotRaconteur::WrappedPipeSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeSubscription > *smartarg1 = 0 ;
  RobotRaconteur::WrappedService_typed_packet result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->ReceivePacket();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::WrappedService_typed_packet((const RobotRaconteur::WrappedService_typed_packet &)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeSubscription_TryReceivePacket(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::WrappedPipeSubscription *arg1 = (RobotRaconteur::WrappedPipeSubscription *) 0 ;
  RobotRaconteur::WrappedService_typed_packet *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeSubscription > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::WrappedService_typed_packet *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::WrappedService_typed_packet & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)(arg1)->TryReceivePacket(*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeSubscription_TryReceivePacketWait__SWIG_0(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
  unsigned int jresult ;
  RobotRaconteur::WrappedPipeSubscription *arg1 = (RobotRaconteur::WrappedPipeSubscription *) 0 ;
  RobotRaconteur::WrappedService_typed_packet *arg2 = 0 ;
  int32_t arg3 ;
  bool arg4 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeSubscription > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::WrappedService_typed_packet *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::WrappedService_typed_packet & type is null", 0);
    return 0;
  } 
  arg3 = (int32_t)jarg3; 
  arg4 = jarg4 ? true : false; 
  
  try {
    result = (bool)(arg1)->TryReceivePacketWait(*arg2,arg3,arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeSubscription_TryReceivePacketWait__SWIG_1(void * jarg1, void * jarg2, int jarg3) {
  unsigned int jresult ;
  RobotRaconteur::WrappedPipeSubscription *arg1 = (RobotRaconteur::WrappedPipeSubscription *) 0 ;
  RobotRaconteur::WrappedService_typed_packet *arg2 = 0 ;
  int32_t arg3 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeSubscription > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::WrappedService_typed_packet *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::WrappedService_typed_packet & type is null", 0);
    return 0;
  } 
  arg3 = (int32_t)jarg3; 
  
  try {
    result = (bool)(arg1)->TryReceivePacketWait(*arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeSubscription_TryReceivePacketWait__SWIG_2(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::WrappedPipeSubscription *arg1 = (RobotRaconteur::WrappedPipeSubscription *) 0 ;
  RobotRaconteur::WrappedService_typed_packet *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeSubscription > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::WrappedService_typed_packet *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::WrappedService_typed_packet & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)(arg1)->TryReceivePacketWait(*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeSubscription_Available(void * jarg1) {
  unsigned long jresult ;
  RobotRaconteur::WrappedPipeSubscription *arg1 = (RobotRaconteur::WrappedPipeSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeSubscription > *smartarg1 = 0 ;
  size_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->Available();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeSubscription_GetActivePipeEndpointCount(void * jarg1) {
  unsigned long jresult ;
  RobotRaconteur::WrappedPipeSubscription *arg1 = (RobotRaconteur::WrappedPipeSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeSubscription > *smartarg1 = 0 ;
  size_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetActivePipeEndpointCount();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeSubscription_GetIgnoreReceived(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::WrappedPipeSubscription *arg1 = (RobotRaconteur::WrappedPipeSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeSubscription > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (bool)(arg1)->GetIgnoreReceived();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeSubscription_SetIgnoreReceived(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::WrappedPipeSubscription *arg1 = (RobotRaconteur::WrappedPipeSubscription *) 0 ;
  bool arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeSubscription > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? true : false; 
  
  try {
    (arg1)->SetIgnoreReceived(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeSubscription_Close(void * jarg1) {
  RobotRaconteur::WrappedPipeSubscription *arg1 = (RobotRaconteur::WrappedPipeSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeSubscription > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->Close();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeSubscription_SetRRDirector(void * jarg1, void * jarg2, int jarg3) {
  RobotRaconteur::WrappedPipeSubscription *arg1 = (RobotRaconteur::WrappedPipeSubscription *) 0 ;
  RobotRaconteur::WrappedPipeSubscriptionDirector *arg2 = (RobotRaconteur::WrappedPipeSubscriptionDirector *) 0 ;
  int32_t arg3 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeSubscription > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::WrappedPipeSubscriptionDirector *)jarg2; 
  arg3 = (int32_t)jarg3; 
  
  try {
    (arg1)->SetRRDirector(arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeSubscription_GetNode(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedPipeSubscription *arg1 = (RobotRaconteur::WrappedPipeSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeSubscription > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetNode();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::RobotRaconteurNode >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedPipeSubscription(void * jarg1) {
  RobotRaconteur::WrappedPipeSubscription *arg1 = (RobotRaconteur::WrappedPipeSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeSubscription > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedPipeSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedPipeSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedPipeSubscription_send_iterator(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeSubscription > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeSubscription > tempnull1 ;
  RobotRaconteur::WrappedPipeSubscription_send_iterator *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::WrappedPipeSubscription > *)jarg1 : &tempnull1; 
  
  try {
    result = (RobotRaconteur::WrappedPipeSubscription_send_iterator *)new RobotRaconteur::WrappedPipeSubscription_send_iterator((boost::shared_ptr< RobotRaconteur::WrappedPipeSubscription > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeSubscription_send_iterator_Next(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedPipeSubscription_send_iterator *arg1 = (RobotRaconteur::WrappedPipeSubscription_send_iterator *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint > result;
  
  arg1 = (RobotRaconteur::WrappedPipeSubscription_send_iterator *)jarg1; 
  
  try {
    result = (arg1)->Next();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedPipeEndpoint >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeSubscription_send_iterator_AsyncSendPacket(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedPipeSubscription_send_iterator *arg1 = (RobotRaconteur::WrappedPipeSubscription_send_iterator *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > *arg2 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > temp2 ;
  boost::shared_ptr< RobotRaconteur::MessageElement > *smartarg2 ;
  
  arg1 = (RobotRaconteur::WrappedPipeSubscription_send_iterator *)jarg1; 
  
  // intrusive_ptr by reference
  if ( jarg2 ) {
    smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElement >**)&jarg2;
    temp2 = boost::intrusive_ptr<  RobotRaconteur::MessageElement >(smartarg2->get(), true);
    arg2 = &temp2;
  } else {
    arg2 = &tempnull2;
  }
  
  
  try {
    (arg1)->AsyncSendPacket((boost::intrusive_ptr< RobotRaconteur::MessageElement > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeSubscription_send_iterator_GetType(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedPipeSubscription_send_iterator *arg1 = (RobotRaconteur::WrappedPipeSubscription_send_iterator *) 0 ;
  boost::shared_ptr< RobotRaconteur::TypeDefinition > result;
  
  arg1 = (RobotRaconteur::WrappedPipeSubscription_send_iterator *)jarg1; 
  
  try {
    result = (arg1)->GetType();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::TypeDefinition >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedPipeSubscription_send_iterator_GetStub(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedPipeSubscription_send_iterator *arg1 = (RobotRaconteur::WrappedPipeSubscription_send_iterator *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > result;
  
  arg1 = (RobotRaconteur::WrappedPipeSubscription_send_iterator *)jarg1; 
  
  try {
    result = (arg1)->GetStub();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceStub >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedPipeSubscription_send_iterator(void * jarg1) {
  RobotRaconteur::WrappedPipeSubscription_send_iterator *arg1 = (RobotRaconteur::WrappedPipeSubscription_send_iterator *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedPipeSubscription_send_iterator *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedSubObjectSubscription_GetDefaultClient(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedSubObjectSubscription *arg1 = (RobotRaconteur::WrappedSubObjectSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedSubObjectSubscription > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedSubObjectSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedSubObjectSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetDefaultClient();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceStub >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedSubObjectSubscription_TryGetDefaultClient(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedSubObjectSubscription *arg1 = (RobotRaconteur::WrappedSubObjectSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedSubObjectSubscription > *smartarg1 = 0 ;
  RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedSubObjectSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedSubObjectSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->TryGetDefaultClient();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes((const RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedSubObjectSubscription_GetDefaultClientWait__SWIG_0(void * jarg1, int jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedSubObjectSubscription *arg1 = (RobotRaconteur::WrappedSubObjectSubscription *) 0 ;
  int32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedSubObjectSubscription > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedSubObjectSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedSubObjectSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  
  try {
    result = (arg1)->GetDefaultClientWait(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceStub >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedSubObjectSubscription_GetDefaultClientWait__SWIG_1(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedSubObjectSubscription *arg1 = (RobotRaconteur::WrappedSubObjectSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedSubObjectSubscription > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedSubObjectSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedSubObjectSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetDefaultClientWait();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceStub >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedSubObjectSubscription_TryGetDefaultClientWait__SWIG_0(void * jarg1, int jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedSubObjectSubscription *arg1 = (RobotRaconteur::WrappedSubObjectSubscription *) 0 ;
  int32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedSubObjectSubscription > *smartarg1 = 0 ;
  RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedSubObjectSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedSubObjectSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  
  try {
    result = (arg1)->TryGetDefaultClientWait(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes((const RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedSubObjectSubscription_TryGetDefaultClientWait__SWIG_1(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedSubObjectSubscription *arg1 = (RobotRaconteur::WrappedSubObjectSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedSubObjectSubscription > *smartarg1 = 0 ;
  RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedSubObjectSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedSubObjectSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->TryGetDefaultClientWait();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes((const RobotRaconteur::WrappedServiceSubscription_TryDefaultClientRes &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedSubObjectSubscription_AsyncGetDefaultClient(void * jarg1, int jarg2, void * jarg3, int jarg4) {
  RobotRaconteur::WrappedSubObjectSubscription *arg1 = (RobotRaconteur::WrappedSubObjectSubscription *) 0 ;
  int32_t arg2 ;
  RobotRaconteur::AsyncStubReturnDirector *arg3 = (RobotRaconteur::AsyncStubReturnDirector *) 0 ;
  int32_t arg4 ;
  boost::shared_ptr< RobotRaconteur::WrappedSubObjectSubscription > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedSubObjectSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedSubObjectSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  arg3 = (RobotRaconteur::AsyncStubReturnDirector *)jarg3; 
  arg4 = (int32_t)jarg4; 
  
  try {
    (arg1)->AsyncGetDefaultClient(arg2,arg3,arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedSubObjectSubscription_Close(void * jarg1) {
  RobotRaconteur::WrappedSubObjectSubscription *arg1 = (RobotRaconteur::WrappedSubObjectSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedSubObjectSubscription > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedSubObjectSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedSubObjectSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->Close();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedSubObjectSubscription_GetNode(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedSubObjectSubscription *arg1 = (RobotRaconteur::WrappedSubObjectSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedSubObjectSubscription > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedSubObjectSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedSubObjectSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetNode();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::RobotRaconteurNode >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedSubObjectSubscription(void * jarg1) {
  RobotRaconteur::WrappedSubObjectSubscription *arg1 = (RobotRaconteur::WrappedSubObjectSubscription *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedSubObjectSubscription > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedSubObjectSubscription > *)jarg1;
  arg1 = (RobotRaconteur::WrappedSubObjectSubscription *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceInfo2SubscriptionServicesToVector(void * jarg1) {
  void * jresult ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped,std::less< RobotRaconteur::ServiceSubscriptionClientID > > *arg1 = 0 ;
  std::vector< RobotRaconteur::ServiceSubscriptionClientID > result;
  
  arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped,std::less< RobotRaconteur::ServiceSubscriptionClientID > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< RobotRaconteur::ServiceSubscriptionClientID,RobotRaconteur::ServiceInfo2Wrapped,std::less< RobotRaconteur::ServiceSubscriptionClientID > > & type is null", 0);
    return 0;
  } 
  
  try {
    result = RobotRaconteur::WrappedServiceInfo2SubscriptionServicesToVector(*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< RobotRaconteur::ServiceSubscriptionClientID >((const std::vector< RobotRaconteur::ServiceSubscriptionClientID > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedSubscribeServiceInfo2__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  std::vector< std::string > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > arg3 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceInfo2Subscription > result;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  arg2 = (std::vector< std::string > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  if (jarg3) arg3 = *(boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > *)jarg3; 
  
  try {
    result = RobotRaconteur::WrappedSubscribeServiceInfo2((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1,(std::vector< std::string > const &)*arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceInfo2Subscription >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedSubscribeServiceInfo2__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  std::vector< std::string > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceInfo2Subscription > result;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  arg2 = (std::vector< std::string > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = RobotRaconteur::WrappedSubscribeServiceInfo2((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1,(std::vector< std::string > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceInfo2Subscription >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionClientsToVector(void * jarg1) {
  void * jresult ;
  std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub >,std::less< RobotRaconteur::ServiceSubscriptionClientID > > *arg1 = 0 ;
  std::vector< RobotRaconteur::ServiceSubscriptionClientID > result;
  
  arg1 = (std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub >,std::less< RobotRaconteur::ServiceSubscriptionClientID > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< RobotRaconteur::ServiceSubscriptionClientID,boost::shared_ptr< RobotRaconteur::WrappedServiceStub >,std::less< RobotRaconteur::ServiceSubscriptionClientID > > & type is null", 0);
    return 0;
  } 
  
  try {
    result = RobotRaconteur::WrappedServiceSubscriptionClientsToVector(*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< RobotRaconteur::ServiceSubscriptionClientID >((const std::vector< RobotRaconteur::ServiceSubscriptionClientID > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedSubscribeServiceByType__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  std::vector< std::string > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > arg3 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > result;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  arg2 = (std::vector< std::string > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  if (jarg3) arg3 = *(boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > *)jarg3; 
  
  try {
    result = RobotRaconteur::WrappedSubscribeServiceByType((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1,(std::vector< std::string > const &)*arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedSubscribeServiceByType__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  std::vector< std::string > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > result;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  arg2 = (std::vector< std::string > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = RobotRaconteur::WrappedSubscribeServiceByType((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1,(std::vector< std::string > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedSubscribeService__SWIG_0(void * jarg1, void * jarg2, char * jarg3, void * jarg4, char * jarg5) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  std::vector< std::string > *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > arg4 ;
  std::string *arg5 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  boost::shared_ptr< RobotRaconteur::MessageElementData > *smartarg4 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > result;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  arg2 = (std::vector< std::string > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  // intrusive_ptr by value
  smartarg4 = *(boost::shared_ptr<  RobotRaconteur::MessageElementData >**)&jarg4;
  if (smartarg4) {
    arg4 = boost::intrusive_ptr<  RobotRaconteur::MessageElementData >(smartarg4->get(), true);
  }
  
  if (!jarg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg5_str(jarg5);
  arg5 = &arg5_str; 
  
  try {
    result = RobotRaconteur::WrappedSubscribeService((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1,(std::vector< std::string > const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedSubscribeService__SWIG_1(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  std::vector< std::string > *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > arg4 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  boost::shared_ptr< RobotRaconteur::MessageElementData > *smartarg4 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > result;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  arg2 = (std::vector< std::string > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  // intrusive_ptr by value
  smartarg4 = *(boost::shared_ptr<  RobotRaconteur::MessageElementData >**)&jarg4;
  if (smartarg4) {
    arg4 = boost::intrusive_ptr<  RobotRaconteur::MessageElementData >(smartarg4->get(), true);
  }
  
  
  try {
    result = RobotRaconteur::WrappedSubscribeService((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1,(std::vector< std::string > const &)*arg2,(std::string const &)*arg3,arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedSubscribeService__SWIG_2(void * jarg1, void * jarg2, char * jarg3) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  std::vector< std::string > *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > result;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  arg2 = (std::vector< std::string > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  try {
    result = RobotRaconteur::WrappedSubscribeService((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1,(std::vector< std::string > const &)*arg2,(std::string const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedSubscribeService__SWIG_3(void * jarg1, void * jarg2) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  std::vector< std::string > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > result;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  arg2 = (std::vector< std::string > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = RobotRaconteur::WrappedSubscribeService((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1,(std::vector< std::string > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedSubscribeService__SWIG_4(void * jarg1, char * jarg2, char * jarg3, void * jarg4, char * jarg5) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > arg4 ;
  std::string *arg5 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  boost::shared_ptr< RobotRaconteur::MessageElementData > *smartarg4 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > result;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  // intrusive_ptr by value
  smartarg4 = *(boost::shared_ptr<  RobotRaconteur::MessageElementData >**)&jarg4;
  if (smartarg4) {
    arg4 = boost::intrusive_ptr<  RobotRaconteur::MessageElementData >(smartarg4->get(), true);
  }
  
  if (!jarg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg5_str(jarg5);
  arg5 = &arg5_str; 
  
  try {
    result = RobotRaconteur::WrappedSubscribeService((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedSubscribeService__SWIG_5(void * jarg1, char * jarg2, char * jarg3, void * jarg4) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > arg4 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  boost::shared_ptr< RobotRaconteur::MessageElementData > *smartarg4 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > result;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  // intrusive_ptr by value
  smartarg4 = *(boost::shared_ptr<  RobotRaconteur::MessageElementData >**)&jarg4;
  if (smartarg4) {
    arg4 = boost::intrusive_ptr<  RobotRaconteur::MessageElementData >(smartarg4->get(), true);
  }
  
  
  try {
    result = RobotRaconteur::WrappedSubscribeService((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedSubscribeService__SWIG_6(void * jarg1, char * jarg2, char * jarg3) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > result;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  try {
    result = RobotRaconteur::WrappedSubscribeService((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedSubscribeService__SWIG_7(void * jarg1, char * jarg2) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > result;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = RobotRaconteur::WrappedSubscribeService((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1,(std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Name_set(void * jarg1, char * jarg2) {
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->Name = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Name_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)jarg1; 
  result = (std::string *) & ((arg1)->Name);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_ConnectionMethod_set(void * jarg1, int jarg2) {
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *) 0 ;
  RobotRaconteur::ServiceSubscriptionManager_CONNECTION_METHOD arg2 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)jarg1; 
  arg2 = (RobotRaconteur::ServiceSubscriptionManager_CONNECTION_METHOD)jarg2; 
  if (arg1) (arg1)->ConnectionMethod = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_ConnectionMethod_get(void * jarg1) {
  int jresult ;
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *) 0 ;
  RobotRaconteur::ServiceSubscriptionManager_CONNECTION_METHOD result;
  
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)jarg1; 
  result = (RobotRaconteur::ServiceSubscriptionManager_CONNECTION_METHOD) ((arg1)->ConnectionMethod);
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Urls_set(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *) 0 ;
  std::vector< std::string > *arg2 = (std::vector< std::string > *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)jarg1; 
  arg2 = (std::vector< std::string > *)jarg2; 
  if (arg1) (arg1)->Urls = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Urls_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *) 0 ;
  std::vector< std::string > *result = 0 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)jarg1; 
  result = (std::vector< std::string > *)& ((arg1)->Urls);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_UrlUsername_set(void * jarg1, char * jarg2) {
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->UrlUsername = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_UrlUsername_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)jarg1; 
  result = (std::string *) & ((arg1)->UrlUsername);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_UrlCredentials_set(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > *arg2 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > temp2 ;
  boost::shared_ptr< RobotRaconteur::MessageElementData > *smartarg2 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)jarg1; 
  
  // intrusive_ptr by reference
  if ( jarg2 ) {
    smartarg2 = *(boost::shared_ptr<  RobotRaconteur::MessageElementData >**)&jarg2;
    temp2 = boost::intrusive_ptr<  RobotRaconteur::MessageElementData >(smartarg2->get(), true);
    arg2 = &temp2;
  } else {
    arg2 = &tempnull2;
  }
  
  if (arg1) (arg1)->UrlCredentials = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_UrlCredentials_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *) 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > *result = 0 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)jarg1; 
  result = (boost::intrusive_ptr< RobotRaconteur::MessageElementData > *) & ((arg1)->UrlCredentials);
  
  if (*result) {
    intrusive_ptr_add_ref(result->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElementData > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElementData >(result->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElementData >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElementData > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_ServiceTypes_set(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *) 0 ;
  std::vector< std::string > *arg2 = (std::vector< std::string > *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)jarg1; 
  arg2 = (std::vector< std::string > *)jarg2; 
  if (arg1) (arg1)->ServiceTypes = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_ServiceTypes_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *) 0 ;
  std::vector< std::string > *result = 0 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)jarg1; 
  result = (std::vector< std::string > *)& ((arg1)->ServiceTypes);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Filter_set(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > tempnull2 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > *)jarg2 : &tempnull2; 
  if (arg1) (arg1)->Filter = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Filter_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > *result = 0 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)jarg1; 
  result = (boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > *) & ((arg1)->Filter);
  jresult = *result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter >(*result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Enabled_set(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *) 0 ;
  bool arg2 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->Enabled = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManagerDetails_Enabled_get(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *) 0 ;
  bool result;
  
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)jarg1; 
  result = (bool) ((arg1)->Enabled);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedServiceSubscriptionManagerDetails__SWIG_0() {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)new RobotRaconteur::WrappedServiceSubscriptionManagerDetails();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedServiceSubscriptionManagerDetails__SWIG_1(char * jarg1, int jarg2, void * jarg3, char * jarg4, void * jarg5, void * jarg6, void * jarg7, unsigned int jarg8) {
  void * jresult ;
  std::string *arg1 = 0 ;
  RobotRaconteur::ServiceSubscriptionManager_CONNECTION_METHOD arg2 ;
  std::vector< std::string > *arg3 = 0 ;
  std::string *arg4 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > *arg5 = 0 ;
  std::vector< std::string > *arg6 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > *arg7 = 0 ;
  bool arg8 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > tempnull5 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > temp5 ;
  boost::shared_ptr< RobotRaconteur::MessageElementData > *smartarg5 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > tempnull7 ;
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (RobotRaconteur::ServiceSubscriptionManager_CONNECTION_METHOD)jarg2; 
  arg3 = (std::vector< std::string > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  if (!jarg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg4_str(jarg4);
  arg4 = &arg4_str; 
  
  // intrusive_ptr by reference
  if ( jarg5 ) {
    smartarg5 = *(boost::shared_ptr<  RobotRaconteur::MessageElementData >**)&jarg5;
    temp5 = boost::intrusive_ptr<  RobotRaconteur::MessageElementData >(smartarg5->get(), true);
    arg5 = &temp5;
  } else {
    arg5 = &tempnull5;
  }
  
  arg6 = (std::vector< std::string > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > *)jarg7 : &tempnull7; 
  arg8 = jarg8 ? true : false; 
  
  try {
    result = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)new RobotRaconteur::WrappedServiceSubscriptionManagerDetails((std::string const &)*arg1,arg2,(std::vector< std::string > const &)*arg3,(std::string const &)*arg4,(boost::intrusive_ptr< RobotRaconteur::MessageElementData > const &)*arg5,(std::vector< std::string > const &)*arg6,(boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > const &)*arg7,arg8);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedServiceSubscriptionManagerDetails__SWIG_2(char * jarg1, int jarg2, void * jarg3, char * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  std::string *arg1 = 0 ;
  RobotRaconteur::ServiceSubscriptionManager_CONNECTION_METHOD arg2 ;
  std::vector< std::string > *arg3 = 0 ;
  std::string *arg4 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > *arg5 = 0 ;
  std::vector< std::string > *arg6 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > *arg7 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > tempnull5 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > temp5 ;
  boost::shared_ptr< RobotRaconteur::MessageElementData > *smartarg5 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > tempnull7 ;
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (RobotRaconteur::ServiceSubscriptionManager_CONNECTION_METHOD)jarg2; 
  arg3 = (std::vector< std::string > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  if (!jarg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg4_str(jarg4);
  arg4 = &arg4_str; 
  
  // intrusive_ptr by reference
  if ( jarg5 ) {
    smartarg5 = *(boost::shared_ptr<  RobotRaconteur::MessageElementData >**)&jarg5;
    temp5 = boost::intrusive_ptr<  RobotRaconteur::MessageElementData >(smartarg5->get(), true);
    arg5 = &temp5;
  } else {
    arg5 = &tempnull5;
  }
  
  arg6 = (std::vector< std::string > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  arg7 = jarg7 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > *)jarg7 : &tempnull7; 
  
  try {
    result = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)new RobotRaconteur::WrappedServiceSubscriptionManagerDetails((std::string const &)*arg1,arg2,(std::vector< std::string > const &)*arg3,(std::string const &)*arg4,(boost::intrusive_ptr< RobotRaconteur::MessageElementData > const &)*arg5,(std::vector< std::string > const &)*arg6,(boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionFilter > const &)*arg7);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedServiceSubscriptionManagerDetails__SWIG_3(char * jarg1, int jarg2, void * jarg3, char * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  std::string *arg1 = 0 ;
  RobotRaconteur::ServiceSubscriptionManager_CONNECTION_METHOD arg2 ;
  std::vector< std::string > *arg3 = 0 ;
  std::string *arg4 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > *arg5 = 0 ;
  std::vector< std::string > *arg6 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > tempnull5 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > temp5 ;
  boost::shared_ptr< RobotRaconteur::MessageElementData > *smartarg5 ;
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (RobotRaconteur::ServiceSubscriptionManager_CONNECTION_METHOD)jarg2; 
  arg3 = (std::vector< std::string > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  if (!jarg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg4_str(jarg4);
  arg4 = &arg4_str; 
  
  // intrusive_ptr by reference
  if ( jarg5 ) {
    smartarg5 = *(boost::shared_ptr<  RobotRaconteur::MessageElementData >**)&jarg5;
    temp5 = boost::intrusive_ptr<  RobotRaconteur::MessageElementData >(smartarg5->get(), true);
    arg5 = &temp5;
  } else {
    arg5 = &tempnull5;
  }
  
  arg6 = (std::vector< std::string > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)new RobotRaconteur::WrappedServiceSubscriptionManagerDetails((std::string const &)*arg1,arg2,(std::vector< std::string > const &)*arg3,(std::string const &)*arg4,(boost::intrusive_ptr< RobotRaconteur::MessageElementData > const &)*arg5,(std::vector< std::string > const &)*arg6);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedServiceSubscriptionManagerDetails__SWIG_4(char * jarg1, int jarg2, void * jarg3, char * jarg4, void * jarg5) {
  void * jresult ;
  std::string *arg1 = 0 ;
  RobotRaconteur::ServiceSubscriptionManager_CONNECTION_METHOD arg2 ;
  std::vector< std::string > *arg3 = 0 ;
  std::string *arg4 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > *arg5 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > tempnull5 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > temp5 ;
  boost::shared_ptr< RobotRaconteur::MessageElementData > *smartarg5 ;
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (RobotRaconteur::ServiceSubscriptionManager_CONNECTION_METHOD)jarg2; 
  arg3 = (std::vector< std::string > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  if (!jarg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg4_str(jarg4);
  arg4 = &arg4_str; 
  
  // intrusive_ptr by reference
  if ( jarg5 ) {
    smartarg5 = *(boost::shared_ptr<  RobotRaconteur::MessageElementData >**)&jarg5;
    temp5 = boost::intrusive_ptr<  RobotRaconteur::MessageElementData >(smartarg5->get(), true);
    arg5 = &temp5;
  } else {
    arg5 = &tempnull5;
  }
  
  
  try {
    result = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)new RobotRaconteur::WrappedServiceSubscriptionManagerDetails((std::string const &)*arg1,arg2,(std::vector< std::string > const &)*arg3,(std::string const &)*arg4,(boost::intrusive_ptr< RobotRaconteur::MessageElementData > const &)*arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedServiceSubscriptionManagerDetails__SWIG_5(char * jarg1, int jarg2, void * jarg3, char * jarg4) {
  void * jresult ;
  std::string *arg1 = 0 ;
  RobotRaconteur::ServiceSubscriptionManager_CONNECTION_METHOD arg2 ;
  std::vector< std::string > *arg3 = 0 ;
  std::string *arg4 = 0 ;
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (RobotRaconteur::ServiceSubscriptionManager_CONNECTION_METHOD)jarg2; 
  arg3 = (std::vector< std::string > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  if (!jarg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg4_str(jarg4);
  arg4 = &arg4_str; 
  
  try {
    result = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)new RobotRaconteur::WrappedServiceSubscriptionManagerDetails((std::string const &)*arg1,arg2,(std::vector< std::string > const &)*arg3,(std::string const &)*arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedServiceSubscriptionManagerDetails__SWIG_6(char * jarg1, int jarg2, void * jarg3) {
  void * jresult ;
  std::string *arg1 = 0 ;
  RobotRaconteur::ServiceSubscriptionManager_CONNECTION_METHOD arg2 ;
  std::vector< std::string > *arg3 = 0 ;
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (RobotRaconteur::ServiceSubscriptionManager_CONNECTION_METHOD)jarg2; 
  arg3 = (std::vector< std::string > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)new RobotRaconteur::WrappedServiceSubscriptionManagerDetails((std::string const &)*arg1,arg2,(std::vector< std::string > const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedServiceSubscriptionManagerDetails__SWIG_7(char * jarg1, int jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  RobotRaconteur::ServiceSubscriptionManager_CONNECTION_METHOD arg2 ;
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (RobotRaconteur::ServiceSubscriptionManager_CONNECTION_METHOD)jarg2; 
  
  try {
    result = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)new RobotRaconteur::WrappedServiceSubscriptionManagerDetails((std::string const &)*arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedServiceSubscriptionManagerDetails__SWIG_8(char * jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  
  try {
    result = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)new RobotRaconteur::WrappedServiceSubscriptionManagerDetails((std::string const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedServiceSubscriptionManagerDetails(void * jarg1) {
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *) 0 ;
  
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedServiceSubscriptionManager__SWIG_0() {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscriptionManager *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::WrappedServiceSubscriptionManager *)new RobotRaconteur::WrappedServiceSubscriptionManager();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionManager >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedServiceSubscriptionManager__SWIG_1(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  RobotRaconteur::WrappedServiceSubscriptionManager *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  
  try {
    result = (RobotRaconteur::WrappedServiceSubscriptionManager *)new RobotRaconteur::WrappedServiceSubscriptionManager((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionManager >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedServiceSubscriptionManager__SWIG_2(void * jarg1) {
  void * jresult ;
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *arg1 = 0 ;
  RobotRaconteur::WrappedServiceSubscriptionManager *result = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (RobotRaconteur::WrappedServiceSubscriptionManager *)new RobotRaconteur::WrappedServiceSubscriptionManager((std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionManager >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedServiceSubscriptionManager__SWIG_3(void * jarg1, void * jarg2) {
  void * jresult ;
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull2 ;
  RobotRaconteur::WrappedServiceSubscriptionManager *result = 0 ;
  
  arg1 = (std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > const & type is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg2 : &tempnull2; 
  
  try {
    result = (RobotRaconteur::WrappedServiceSubscriptionManager *)new RobotRaconteur::WrappedServiceSubscriptionManager((std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > const &)*arg1,(boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionManager >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManager_AddSubscription(void * jarg1, void * jarg2) {
  RobotRaconteur::WrappedServiceSubscriptionManager *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *) 0 ;
  RobotRaconteur::WrappedServiceSubscriptionManagerDetails *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionManager > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionManager > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::WrappedServiceSubscriptionManagerDetails *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::WrappedServiceSubscriptionManagerDetails const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->AddSubscription((RobotRaconteur::WrappedServiceSubscriptionManagerDetails const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManager_RemoveSubscription__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
  RobotRaconteur::WrappedServiceSubscriptionManager *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionManager > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionManager > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  
  try {
    (arg1)->RemoveSubscription((std::string const &)*arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManager_RemoveSubscription__SWIG_1(void * jarg1, char * jarg2) {
  RobotRaconteur::WrappedServiceSubscriptionManager *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionManager > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionManager > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->RemoveSubscription((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManager_EnableSubscription(void * jarg1, char * jarg2) {
  RobotRaconteur::WrappedServiceSubscriptionManager *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionManager > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionManager > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->EnableSubscription((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManager_DisableSubscription__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
  RobotRaconteur::WrappedServiceSubscriptionManager *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionManager > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionManager > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  
  try {
    (arg1)->DisableSubscription((std::string const &)*arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManager_DisableSubscription__SWIG_1(void * jarg1, char * jarg2) {
  RobotRaconteur::WrappedServiceSubscriptionManager *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionManager > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionManager > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->DisableSubscription((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManager_GetSubscription__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscriptionManager *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionManager > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionManager > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  
  try {
    result = (arg1)->GetSubscription((std::string const &)*arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManager_GetSubscription__SWIG_1(void * jarg1, char * jarg2) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscriptionManager *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionManager > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionManager > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (arg1)->GetSubscription((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceSubscription >(result) : 0; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManager_IsConnected(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::WrappedServiceSubscriptionManager *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionManager > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionManager > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (bool)(arg1)->IsConnected((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManager_IsEnabled(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::WrappedServiceSubscriptionManager *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionManager > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionManager > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (bool)(arg1)->IsEnabled((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManager_Close__SWIG_0(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::WrappedServiceSubscriptionManager *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *) 0 ;
  bool arg2 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionManager > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionManager > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? true : false; 
  
  try {
    (arg1)->Close(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManager_Close__SWIG_1(void * jarg1) {
  RobotRaconteur::WrappedServiceSubscriptionManager *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionManager > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionManager > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->Close();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManager_GetSubscriptionNames(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscriptionManager *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionManager > *smartarg1 = 0 ;
  std::vector< std::string > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionManager > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetSubscriptionNames();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< std::string >((const std::vector< std::string > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManager_GetSubscriptionDetails(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscriptionManager *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionManager > *smartarg1 = 0 ;
  std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionManager > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetSubscriptionDetails();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails >((const std::vector< RobotRaconteur::WrappedServiceSubscriptionManagerDetails > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceSubscriptionManager_GetNode(void * jarg1) {
  void * jresult ;
  RobotRaconteur::WrappedServiceSubscriptionManager *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionManager > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionManager > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetNode();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::RobotRaconteurNode >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedServiceSubscriptionManager(void * jarg1) {
  RobotRaconteur::WrappedServiceSubscriptionManager *arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceSubscriptionManager > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::WrappedServiceSubscriptionManager > *)jarg1;
  arg1 = (RobotRaconteur::WrappedServiceSubscriptionManager *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RRLogRecord__GetNode(void * jarg1) {
  void * jresult ;
  RobotRaconteur::RRLogRecord *arg1 = (RobotRaconteur::RRLogRecord *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > result;
  
  arg1 = (RobotRaconteur::RRLogRecord *)jarg1; 
  
  try {
    result = RobotRaconteur_RRLogRecord_GetNode(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::RobotRaconteurNode >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RRLogRecord__SetNode(void * jarg1, void * jarg2) {
  RobotRaconteur::RRLogRecord *arg1 = (RobotRaconteur::RRLogRecord *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull2 ;
  
  arg1 = (RobotRaconteur::RRLogRecord *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg2 : &tempnull2; 
  
  try {
    RobotRaconteur_RRLogRecord_SetNode(arg1,(boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RRLogRecord_Level_set(void * jarg1, int jarg2) {
  RobotRaconteur::RRLogRecord *arg1 = (RobotRaconteur::RRLogRecord *) 0 ;
  RobotRaconteur::RobotRaconteur_LogLevel arg2 ;
  
  arg1 = (RobotRaconteur::RRLogRecord *)jarg1; 
  arg2 = (RobotRaconteur::RobotRaconteur_LogLevel)jarg2; 
  if (arg1) (arg1)->Level = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_RRLogRecord_Level_get(void * jarg1) {
  int jresult ;
  RobotRaconteur::RRLogRecord *arg1 = (RobotRaconteur::RRLogRecord *) 0 ;
  RobotRaconteur::RobotRaconteur_LogLevel result;
  
  arg1 = (RobotRaconteur::RRLogRecord *)jarg1; 
  result = (RobotRaconteur::RobotRaconteur_LogLevel) ((arg1)->Level);
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RRLogRecord_Component_set(void * jarg1, int jarg2) {
  RobotRaconteur::RRLogRecord *arg1 = (RobotRaconteur::RRLogRecord *) 0 ;
  RobotRaconteur::RobotRaconteur_LogComponent arg2 ;
  
  arg1 = (RobotRaconteur::RRLogRecord *)jarg1; 
  arg2 = (RobotRaconteur::RobotRaconteur_LogComponent)jarg2; 
  if (arg1) (arg1)->Component = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_RRLogRecord_Component_get(void * jarg1) {
  int jresult ;
  RobotRaconteur::RRLogRecord *arg1 = (RobotRaconteur::RRLogRecord *) 0 ;
  RobotRaconteur::RobotRaconteur_LogComponent result;
  
  arg1 = (RobotRaconteur::RRLogRecord *)jarg1; 
  result = (RobotRaconteur::RobotRaconteur_LogComponent) ((arg1)->Component);
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RRLogRecord_ComponentName_set(void * jarg1, char * jarg2) {
  RobotRaconteur::RRLogRecord *arg1 = (RobotRaconteur::RRLogRecord *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::RRLogRecord *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->ComponentName = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_RRLogRecord_ComponentName_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::RRLogRecord *arg1 = (RobotRaconteur::RRLogRecord *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (RobotRaconteur::RRLogRecord *)jarg1; 
  result = (std::string *) & ((arg1)->ComponentName);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RRLogRecord_ComponentObjectID_set(void * jarg1, char * jarg2) {
  RobotRaconteur::RRLogRecord *arg1 = (RobotRaconteur::RRLogRecord *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::RRLogRecord *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->ComponentObjectID = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_RRLogRecord_ComponentObjectID_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::RRLogRecord *arg1 = (RobotRaconteur::RRLogRecord *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (RobotRaconteur::RRLogRecord *)jarg1; 
  result = (std::string *) & ((arg1)->ComponentObjectID);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RRLogRecord_Endpoint_set(void * jarg1, long long jarg2) {
  RobotRaconteur::RRLogRecord *arg1 = (RobotRaconteur::RRLogRecord *) 0 ;
  int64_t arg2 ;
  
  arg1 = (RobotRaconteur::RRLogRecord *)jarg1; 
  arg2 = (int64_t)jarg2; 
  if (arg1) (arg1)->Endpoint = arg2;
}


SWIGEXPORT long long SWIGSTDCALL CSharp_RobotRaconteur_RRLogRecord_Endpoint_get(void * jarg1) {
  long long jresult ;
  RobotRaconteur::RRLogRecord *arg1 = (RobotRaconteur::RRLogRecord *) 0 ;
  int64_t result;
  
  arg1 = (RobotRaconteur::RRLogRecord *)jarg1; 
  result = (int64_t) ((arg1)->Endpoint);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RRLogRecord_ServicePath_set(void * jarg1, char * jarg2) {
  RobotRaconteur::RRLogRecord *arg1 = (RobotRaconteur::RRLogRecord *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::RRLogRecord *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->ServicePath = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_RRLogRecord_ServicePath_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::RRLogRecord *arg1 = (RobotRaconteur::RRLogRecord *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (RobotRaconteur::RRLogRecord *)jarg1; 
  result = (std::string *) & ((arg1)->ServicePath);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RRLogRecord_Member_set(void * jarg1, char * jarg2) {
  RobotRaconteur::RRLogRecord *arg1 = (RobotRaconteur::RRLogRecord *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::RRLogRecord *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->Member = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_RRLogRecord_Member_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::RRLogRecord *arg1 = (RobotRaconteur::RRLogRecord *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (RobotRaconteur::RRLogRecord *)jarg1; 
  result = (std::string *) & ((arg1)->Member);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RRLogRecord_Message_set(void * jarg1, char * jarg2) {
  RobotRaconteur::RRLogRecord *arg1 = (RobotRaconteur::RRLogRecord *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::RRLogRecord *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->Message = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_RRLogRecord_Message_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::RRLogRecord *arg1 = (RobotRaconteur::RRLogRecord *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (RobotRaconteur::RRLogRecord *)jarg1; 
  result = (std::string *) & ((arg1)->Message);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RRLogRecord_Time_set(void * jarg1, int64_t jarg2) {
  RobotRaconteur::RRLogRecord *arg1 = (RobotRaconteur::RRLogRecord *) 0 ;
  boost::posix_time::ptime arg2 ;
  
  arg1 = (RobotRaconteur::RRLogRecord *)jarg1; 
  {
    arg2 = boost::posix_time::ptime(boost::gregorian::date(1970,1,1),boost::posix_time::time_duration(0,0,0)) + boost::posix_time::microseconds(jarg2/10);
  }
  if (arg1) (arg1)->Time = arg2;
}


SWIGEXPORT int64_t SWIGSTDCALL CSharp_RobotRaconteur_RRLogRecord_Time_get(void * jarg1) {
  int64_t jresult ;
  RobotRaconteur::RRLogRecord *arg1 = (RobotRaconteur::RRLogRecord *) 0 ;
  boost::posix_time::ptime result;
  
  arg1 = (RobotRaconteur::RRLogRecord *)jarg1; 
  result =  ((arg1)->Time);
  {
    {
      boost::posix_time::time_duration ptime_diff = (result - boost::posix_time::ptime(boost::gregorian::date(1970,1,1),boost::posix_time::time_duration(0,0,0)));
      jresult=ptime_diff.total_microseconds()*10;
    }
  }
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RRLogRecord_SourceFile_set(void * jarg1, char * jarg2) {
  RobotRaconteur::RRLogRecord *arg1 = (RobotRaconteur::RRLogRecord *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::RRLogRecord *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->SourceFile = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_RRLogRecord_SourceFile_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::RRLogRecord *arg1 = (RobotRaconteur::RRLogRecord *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (RobotRaconteur::RRLogRecord *)jarg1; 
  result = (std::string *) & ((arg1)->SourceFile);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RRLogRecord_SourceLine_set(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::RRLogRecord *arg1 = (RobotRaconteur::RRLogRecord *) 0 ;
  uint32_t arg2 ;
  
  arg1 = (RobotRaconteur::RRLogRecord *)jarg1; 
  arg2 = (uint32_t)jarg2; 
  if (arg1) (arg1)->SourceLine = arg2;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_RRLogRecord_SourceLine_get(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::RRLogRecord *arg1 = (RobotRaconteur::RRLogRecord *) 0 ;
  uint32_t result;
  
  arg1 = (RobotRaconteur::RRLogRecord *)jarg1; 
  result = (uint32_t) ((arg1)->SourceLine);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RRLogRecord_ThreadID_set(void * jarg1, char * jarg2) {
  RobotRaconteur::RRLogRecord *arg1 = (RobotRaconteur::RRLogRecord *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::RRLogRecord *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->ThreadID = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_RRLogRecord_ThreadID_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::RRLogRecord *arg1 = (RobotRaconteur::RRLogRecord *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (RobotRaconteur::RRLogRecord *)jarg1; 
  result = (std::string *) & ((arg1)->ThreadID);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RRLogRecord_FiberID_set(void * jarg1, char * jarg2) {
  RobotRaconteur::RRLogRecord *arg1 = (RobotRaconteur::RRLogRecord *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::RRLogRecord *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->FiberID = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_RRLogRecord_FiberID_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::RRLogRecord *arg1 = (RobotRaconteur::RRLogRecord *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (RobotRaconteur::RRLogRecord *)jarg1; 
  result = (std::string *) & ((arg1)->FiberID);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_RRLogRecord_ToString(void * jarg1) {
  char * jresult ;
  RobotRaconteur::RRLogRecord *arg1 = (RobotRaconteur::RRLogRecord *) 0 ;
  std::string result;
  
  arg1 = (RobotRaconteur::RRLogRecord *)jarg1; 
  
  try {
    result = RobotRaconteur_RRLogRecord_ToString(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_RRLogRecord() {
  void * jresult ;
  RobotRaconteur::RRLogRecord *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::RRLogRecord *)new RobotRaconteur::RRLogRecord();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_RRLogRecord(void * jarg1) {
  RobotRaconteur::RRLogRecord *arg1 = (RobotRaconteur::RRLogRecord *) 0 ;
  
  arg1 = (RobotRaconteur::RRLogRecord *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_LogRecordHandler(void * jarg1) {
  RobotRaconteur::LogRecordHandler *arg1 = (RobotRaconteur::LogRecordHandler *) 0 ;
  boost::shared_ptr< RobotRaconteur::LogRecordHandler > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::LogRecordHandler > *)jarg1;
  arg1 = (RobotRaconteur::LogRecordHandler *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_FileLogRecordHandler_OpenFile__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
  RobotRaconteur::FileLogRecordHandler *arg1 = (RobotRaconteur::FileLogRecordHandler *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  boost::shared_ptr< RobotRaconteur::FileLogRecordHandler > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::FileLogRecordHandler > *)jarg1;
  arg1 = (RobotRaconteur::FileLogRecordHandler *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  
  try {
    (arg1)->OpenFile((std::string const &)*arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_FileLogRecordHandler_OpenFile__SWIG_1(void * jarg1, char * jarg2) {
  RobotRaconteur::FileLogRecordHandler *arg1 = (RobotRaconteur::FileLogRecordHandler *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::FileLogRecordHandler > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::FileLogRecordHandler > *)jarg1;
  arg1 = (RobotRaconteur::FileLogRecordHandler *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->OpenFile((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_FileLogRecordHandler() {
  void * jresult ;
  RobotRaconteur::FileLogRecordHandler *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::FileLogRecordHandler *)new RobotRaconteur::FileLogRecordHandler();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::FileLogRecordHandler >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_FileLogRecordHandler(void * jarg1) {
  RobotRaconteur::FileLogRecordHandler *arg1 = (RobotRaconteur::FileLogRecordHandler *) 0 ;
  boost::shared_ptr< RobotRaconteur::FileLogRecordHandler > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::FileLogRecordHandler > *)jarg1;
  arg1 = (RobotRaconteur::FileLogRecordHandler *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_UserLogRecordHandlerDirector_HandleLogRecord(void * jarg1, void * jarg2) {
  RobotRaconteur::UserLogRecordHandlerDirector *arg1 = (RobotRaconteur::UserLogRecordHandlerDirector *) 0 ;
  RobotRaconteur::RRLogRecord *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::UserLogRecordHandlerDirector *)jarg1; 
  arg2 = (RobotRaconteur::RRLogRecord *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::RRLogRecord const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->HandleLogRecord((RobotRaconteur::RRLogRecord const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_UserLogRecordHandlerDirector(void * jarg1) {
  RobotRaconteur::UserLogRecordHandlerDirector *arg1 = (RobotRaconteur::UserLogRecordHandlerDirector *) 0 ;
  
  arg1 = (RobotRaconteur::UserLogRecordHandlerDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_UserLogRecordHandlerDirector() {
  void * jresult ;
  RobotRaconteur::UserLogRecordHandlerDirector *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::UserLogRecordHandlerDirector *)new SwigDirector_UserLogRecordHandlerDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_UserLogRecordHandlerDirector_director_connect(void *objarg, SwigDirector_UserLogRecordHandlerDirector::SWIG_Callback0_t callback0) {
  RobotRaconteur::UserLogRecordHandlerDirector *obj = (RobotRaconteur::UserLogRecordHandlerDirector *)objarg;
  SwigDirector_UserLogRecordHandlerDirector *director = static_cast<SwigDirector_UserLogRecordHandlerDirector *>(obj);
  director->swig_connect_director(callback0);
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_UserLogRecordHandlerBase__SetHandler(void * jarg1, void * jarg2, int jarg3) {
  RobotRaconteur::UserLogRecordHandlerBase *arg1 = (RobotRaconteur::UserLogRecordHandlerBase *) 0 ;
  RobotRaconteur::UserLogRecordHandlerDirector *arg2 = (RobotRaconteur::UserLogRecordHandlerDirector *) 0 ;
  int32_t arg3 ;
  boost::shared_ptr< RobotRaconteur::UserLogRecordHandlerBase > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::UserLogRecordHandlerBase > *)jarg1;
  arg1 = (RobotRaconteur::UserLogRecordHandlerBase *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::UserLogRecordHandlerDirector *)jarg2; 
  arg3 = (int32_t)jarg3; 
  
  try {
    (arg1)->SetHandler(arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_UserLogRecordHandlerBase() {
  void * jresult ;
  RobotRaconteur::UserLogRecordHandlerBase *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::UserLogRecordHandlerBase *)new RobotRaconteur::UserLogRecordHandlerBase();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::UserLogRecordHandlerBase >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_UserLogRecordHandlerBase(void * jarg1) {
  RobotRaconteur::UserLogRecordHandlerBase *arg1 = (RobotRaconteur::UserLogRecordHandlerBase *) 0 ;
  boost::shared_ptr< RobotRaconteur::UserLogRecordHandlerBase > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::UserLogRecordHandlerBase > *)jarg1;
  arg1 = (RobotRaconteur::UserLogRecordHandlerBase *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_NodeDirectories_system_data_dir_set(void * jarg1, void * jarg2) {
  RobotRaconteur::NodeDirectories *arg1 = (RobotRaconteur::NodeDirectories *) 0 ;
  boost::filesystem::path *arg2 = (boost::filesystem::path *) 0 ;
  
  arg1 = (RobotRaconteur::NodeDirectories *)jarg1; 
  arg2 = (boost::filesystem::path *)jarg2; 
  if (arg1) (arg1)->system_data_dir = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_NodeDirectories_system_data_dir_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::NodeDirectories *arg1 = (RobotRaconteur::NodeDirectories *) 0 ;
  boost::filesystem::path *result = 0 ;
  
  arg1 = (RobotRaconteur::NodeDirectories *)jarg1; 
  result = (boost::filesystem::path *)& ((arg1)->system_data_dir);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_NodeDirectories_system_config_dir_set(void * jarg1, void * jarg2) {
  RobotRaconteur::NodeDirectories *arg1 = (RobotRaconteur::NodeDirectories *) 0 ;
  boost::filesystem::path *arg2 = (boost::filesystem::path *) 0 ;
  
  arg1 = (RobotRaconteur::NodeDirectories *)jarg1; 
  arg2 = (boost::filesystem::path *)jarg2; 
  if (arg1) (arg1)->system_config_dir = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_NodeDirectories_system_config_dir_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::NodeDirectories *arg1 = (RobotRaconteur::NodeDirectories *) 0 ;
  boost::filesystem::path *result = 0 ;
  
  arg1 = (RobotRaconteur::NodeDirectories *)jarg1; 
  result = (boost::filesystem::path *)& ((arg1)->system_config_dir);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_NodeDirectories_system_state_dir_set(void * jarg1, void * jarg2) {
  RobotRaconteur::NodeDirectories *arg1 = (RobotRaconteur::NodeDirectories *) 0 ;
  boost::filesystem::path *arg2 = (boost::filesystem::path *) 0 ;
  
  arg1 = (RobotRaconteur::NodeDirectories *)jarg1; 
  arg2 = (boost::filesystem::path *)jarg2; 
  if (arg1) (arg1)->system_state_dir = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_NodeDirectories_system_state_dir_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::NodeDirectories *arg1 = (RobotRaconteur::NodeDirectories *) 0 ;
  boost::filesystem::path *result = 0 ;
  
  arg1 = (RobotRaconteur::NodeDirectories *)jarg1; 
  result = (boost::filesystem::path *)& ((arg1)->system_state_dir);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_NodeDirectories_system_cache_dir_set(void * jarg1, void * jarg2) {
  RobotRaconteur::NodeDirectories *arg1 = (RobotRaconteur::NodeDirectories *) 0 ;
  boost::filesystem::path *arg2 = (boost::filesystem::path *) 0 ;
  
  arg1 = (RobotRaconteur::NodeDirectories *)jarg1; 
  arg2 = (boost::filesystem::path *)jarg2; 
  if (arg1) (arg1)->system_cache_dir = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_NodeDirectories_system_cache_dir_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::NodeDirectories *arg1 = (RobotRaconteur::NodeDirectories *) 0 ;
  boost::filesystem::path *result = 0 ;
  
  arg1 = (RobotRaconteur::NodeDirectories *)jarg1; 
  result = (boost::filesystem::path *)& ((arg1)->system_cache_dir);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_NodeDirectories_system_run_dir_set(void * jarg1, void * jarg2) {
  RobotRaconteur::NodeDirectories *arg1 = (RobotRaconteur::NodeDirectories *) 0 ;
  boost::filesystem::path *arg2 = (boost::filesystem::path *) 0 ;
  
  arg1 = (RobotRaconteur::NodeDirectories *)jarg1; 
  arg2 = (boost::filesystem::path *)jarg2; 
  if (arg1) (arg1)->system_run_dir = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_NodeDirectories_system_run_dir_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::NodeDirectories *arg1 = (RobotRaconteur::NodeDirectories *) 0 ;
  boost::filesystem::path *result = 0 ;
  
  arg1 = (RobotRaconteur::NodeDirectories *)jarg1; 
  result = (boost::filesystem::path *)& ((arg1)->system_run_dir);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_NodeDirectories_user_data_dir_set(void * jarg1, void * jarg2) {
  RobotRaconteur::NodeDirectories *arg1 = (RobotRaconteur::NodeDirectories *) 0 ;
  boost::filesystem::path *arg2 = (boost::filesystem::path *) 0 ;
  
  arg1 = (RobotRaconteur::NodeDirectories *)jarg1; 
  arg2 = (boost::filesystem::path *)jarg2; 
  if (arg1) (arg1)->user_data_dir = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_NodeDirectories_user_data_dir_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::NodeDirectories *arg1 = (RobotRaconteur::NodeDirectories *) 0 ;
  boost::filesystem::path *result = 0 ;
  
  arg1 = (RobotRaconteur::NodeDirectories *)jarg1; 
  result = (boost::filesystem::path *)& ((arg1)->user_data_dir);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_NodeDirectories_user_config_dir_set(void * jarg1, void * jarg2) {
  RobotRaconteur::NodeDirectories *arg1 = (RobotRaconteur::NodeDirectories *) 0 ;
  boost::filesystem::path *arg2 = (boost::filesystem::path *) 0 ;
  
  arg1 = (RobotRaconteur::NodeDirectories *)jarg1; 
  arg2 = (boost::filesystem::path *)jarg2; 
  if (arg1) (arg1)->user_config_dir = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_NodeDirectories_user_config_dir_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::NodeDirectories *arg1 = (RobotRaconteur::NodeDirectories *) 0 ;
  boost::filesystem::path *result = 0 ;
  
  arg1 = (RobotRaconteur::NodeDirectories *)jarg1; 
  result = (boost::filesystem::path *)& ((arg1)->user_config_dir);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_NodeDirectories_user_state_dir_set(void * jarg1, void * jarg2) {
  RobotRaconteur::NodeDirectories *arg1 = (RobotRaconteur::NodeDirectories *) 0 ;
  boost::filesystem::path *arg2 = (boost::filesystem::path *) 0 ;
  
  arg1 = (RobotRaconteur::NodeDirectories *)jarg1; 
  arg2 = (boost::filesystem::path *)jarg2; 
  if (arg1) (arg1)->user_state_dir = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_NodeDirectories_user_state_dir_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::NodeDirectories *arg1 = (RobotRaconteur::NodeDirectories *) 0 ;
  boost::filesystem::path *result = 0 ;
  
  arg1 = (RobotRaconteur::NodeDirectories *)jarg1; 
  result = (boost::filesystem::path *)& ((arg1)->user_state_dir);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_NodeDirectories_user_cache_dir_set(void * jarg1, void * jarg2) {
  RobotRaconteur::NodeDirectories *arg1 = (RobotRaconteur::NodeDirectories *) 0 ;
  boost::filesystem::path *arg2 = (boost::filesystem::path *) 0 ;
  
  arg1 = (RobotRaconteur::NodeDirectories *)jarg1; 
  arg2 = (boost::filesystem::path *)jarg2; 
  if (arg1) (arg1)->user_cache_dir = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_NodeDirectories_user_cache_dir_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::NodeDirectories *arg1 = (RobotRaconteur::NodeDirectories *) 0 ;
  boost::filesystem::path *result = 0 ;
  
  arg1 = (RobotRaconteur::NodeDirectories *)jarg1; 
  result = (boost::filesystem::path *)& ((arg1)->user_cache_dir);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_NodeDirectories_user_run_dir_set(void * jarg1, void * jarg2) {
  RobotRaconteur::NodeDirectories *arg1 = (RobotRaconteur::NodeDirectories *) 0 ;
  boost::filesystem::path *arg2 = (boost::filesystem::path *) 0 ;
  
  arg1 = (RobotRaconteur::NodeDirectories *)jarg1; 
  arg2 = (boost::filesystem::path *)jarg2; 
  if (arg1) (arg1)->user_run_dir = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_NodeDirectories_user_run_dir_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::NodeDirectories *arg1 = (RobotRaconteur::NodeDirectories *) 0 ;
  boost::filesystem::path *result = 0 ;
  
  arg1 = (RobotRaconteur::NodeDirectories *)jarg1; 
  result = (boost::filesystem::path *)& ((arg1)->user_run_dir);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_NodeDirectories() {
  void * jresult ;
  RobotRaconteur::NodeDirectories *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::NodeDirectories *)new RobotRaconteur::NodeDirectories();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_NodeDirectories(void * jarg1) {
  RobotRaconteur::NodeDirectories *arg1 = (RobotRaconteur::NodeDirectories *) 0 ;
  
  arg1 = (RobotRaconteur::NodeDirectories *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_NodeDirectoriesFD(void * jarg1) {
  RobotRaconteur::NodeDirectoriesFD *arg1 = (RobotRaconteur::NodeDirectoriesFD *) 0 ;
  boost::shared_ptr< RobotRaconteur::NodeDirectoriesFD > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::NodeDirectoriesFD > *)jarg1;
  arg1 = (RobotRaconteur::NodeDirectoriesFD *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_NodeDirectoriesUtil_GetDefaultNodeDirectories__SWIG_0(void * jarg1) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > arg1 ;
  RobotRaconteur::NodeDirectories result;
  
  if (jarg1) arg1 = *(boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1; 
  
  try {
    result = RobotRaconteur::NodeDirectoriesUtil::GetDefaultNodeDirectories(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::NodeDirectories((const RobotRaconteur::NodeDirectories &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_NodeDirectoriesUtil_GetDefaultNodeDirectories__SWIG_1() {
  void * jresult ;
  RobotRaconteur::NodeDirectories result;
  
  
  try {
    result = RobotRaconteur::NodeDirectoriesUtil::GetDefaultNodeDirectories();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::NodeDirectories((const RobotRaconteur::NodeDirectories &)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_NodeDirectoriesUtil_GetLogonUserName() {
  char * jresult ;
  std::string result;
  
  
  try {
    result = RobotRaconteur::NodeDirectoriesUtil::GetLogonUserName();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_NodeDirectoriesUtil_IsLogonUserRoot() {
  unsigned int jresult ;
  bool result;
  
  
  try {
    result = (bool)RobotRaconteur::NodeDirectoriesUtil::IsLogonUserRoot();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_NodeDirectoriesUtil_ReadInfoFile(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  boost::filesystem::path *arg1 = 0 ;
  std::map< std::string,std::string,std::less< std::string > > *arg2 = 0 ;
  bool result;
  
  arg1 = (boost::filesystem::path *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::filesystem::path const & type is null", 0);
    return 0;
  } 
  arg2 = (std::map< std::string,std::string,std::less< std::string > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< std::string,std::string,std::less< std::string > > & type is null", 0);
    return 0;
  } 
  
  try {
    result = (bool)RobotRaconteur::NodeDirectoriesUtil::ReadInfoFile((boost::filesystem::path const &)*arg1,*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_NodeDirectoriesUtil_CreatePidFile(void * jarg1) {
  void * jresult ;
  boost::filesystem::path *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::NodeDirectoriesFD > result;
  
  arg1 = (boost::filesystem::path *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::filesystem::path const & type is null", 0);
    return 0;
  } 
  
  try {
    result = RobotRaconteur::NodeDirectoriesUtil::CreatePidFile((boost::filesystem::path const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::NodeDirectoriesFD >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_NodeDirectoriesUtil_CreateInfoFile(void * jarg1, void * jarg2) {
  void * jresult ;
  boost::filesystem::path *arg1 = 0 ;
  std::map< std::string,std::string,std::less< std::string > > arg2 ;
  std::map< std::string,std::string,std::less< std::string > > *argp2 ;
  boost::shared_ptr< RobotRaconteur::NodeDirectoriesFD > result;
  
  arg1 = (boost::filesystem::path *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "boost::filesystem::path const & type is null", 0);
    return 0;
  } 
  argp2 = (std::map< std::string,std::string,std::less< std::string > > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::map< std::string,std::string,std::less< std::string > >", 0);
    return 0;
  }
  arg2 = *argp2; 
  
  try {
    result = RobotRaconteur::NodeDirectoriesUtil::CreateInfoFile((boost::filesystem::path const &)*arg1,arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::NodeDirectoriesFD >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_NodeDirectoriesUtil_RefreshInfoFile(void * jarg1, void * jarg2) {
  boost::shared_ptr< RobotRaconteur::NodeDirectoriesFD > *arg1 = 0 ;
  std::map< std::string,std::string,std::less< std::string > > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::NodeDirectoriesFD > tempnull1 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::NodeDirectoriesFD > *)jarg1 : &tempnull1; 
  arg2 = (std::map< std::string,std::string,std::less< std::string > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< std::string,std::string,std::less< std::string > > const & type is null", 0);
    return ;
  } 
  
  try {
    RobotRaconteur::NodeDirectoriesUtil::RefreshInfoFile((boost::shared_ptr< RobotRaconteur::NodeDirectoriesFD > const &)*arg1,(std::map< std::string,std::string,std::less< std::string > > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_NodeDirectoriesUtil() {
  void * jresult ;
  RobotRaconteur::NodeDirectoriesUtil *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::NodeDirectoriesUtil *)new RobotRaconteur::NodeDirectoriesUtil();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_NodeDirectoriesUtil(void * jarg1) {
  RobotRaconteur::NodeDirectoriesUtil *arg1 = (RobotRaconteur::NodeDirectoriesUtil *) 0 ;
  
  arg1 = (RobotRaconteur::NodeDirectoriesUtil *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_GetUuidForNameAndLockResult_uuid_set(void * jarg1, void * jarg2) {
  RobotRaconteur::GetUuidForNameAndLockResult *arg1 = (RobotRaconteur::GetUuidForNameAndLockResult *) 0 ;
  RobotRaconteur::NodeID *arg2 = (RobotRaconteur::NodeID *) 0 ;
  
  arg1 = (RobotRaconteur::GetUuidForNameAndLockResult *)jarg1; 
  arg2 = (RobotRaconteur::NodeID *)jarg2; 
  if (arg1) (arg1)->uuid = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_GetUuidForNameAndLockResult_uuid_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::GetUuidForNameAndLockResult *arg1 = (RobotRaconteur::GetUuidForNameAndLockResult *) 0 ;
  RobotRaconteur::NodeID *result = 0 ;
  
  arg1 = (RobotRaconteur::GetUuidForNameAndLockResult *)jarg1; 
  result = (RobotRaconteur::NodeID *)& ((arg1)->uuid);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_GetUuidForNameAndLockResult_name_set(void * jarg1, char * jarg2) {
  RobotRaconteur::GetUuidForNameAndLockResult *arg1 = (RobotRaconteur::GetUuidForNameAndLockResult *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (RobotRaconteur::GetUuidForNameAndLockResult *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (arg1) (arg1)->name = *arg2;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_GetUuidForNameAndLockResult_name_get(void * jarg1) {
  char * jresult ;
  RobotRaconteur::GetUuidForNameAndLockResult *arg1 = (RobotRaconteur::GetUuidForNameAndLockResult *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (RobotRaconteur::GetUuidForNameAndLockResult *)jarg1; 
  result = (std::string *) & ((arg1)->name);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_GetUuidForNameAndLockResult_scope_set(void * jarg1, void * jarg2) {
  RobotRaconteur::GetUuidForNameAndLockResult *arg1 = (RobotRaconteur::GetUuidForNameAndLockResult *) 0 ;
  std::vector< std::string > *arg2 = (std::vector< std::string > *) 0 ;
  
  arg1 = (RobotRaconteur::GetUuidForNameAndLockResult *)jarg1; 
  arg2 = (std::vector< std::string > *)jarg2; 
  if (arg1) (arg1)->scope = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_GetUuidForNameAndLockResult_scope_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::GetUuidForNameAndLockResult *arg1 = (RobotRaconteur::GetUuidForNameAndLockResult *) 0 ;
  std::vector< std::string > *result = 0 ;
  
  arg1 = (RobotRaconteur::GetUuidForNameAndLockResult *)jarg1; 
  result = (std::vector< std::string > *)& ((arg1)->scope);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_GetUuidForNameAndLockResult_fd_set(void * jarg1, void * jarg2) {
  RobotRaconteur::GetUuidForNameAndLockResult *arg1 = (RobotRaconteur::GetUuidForNameAndLockResult *) 0 ;
  boost::shared_ptr< RobotRaconteur::NodeDirectoriesFD > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::NodeDirectoriesFD > tempnull2 ;
  
  arg1 = (RobotRaconteur::GetUuidForNameAndLockResult *)jarg1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::NodeDirectoriesFD > *)jarg2 : &tempnull2; 
  if (arg1) (arg1)->fd = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_GetUuidForNameAndLockResult_fd_get(void * jarg1) {
  void * jresult ;
  RobotRaconteur::GetUuidForNameAndLockResult *arg1 = (RobotRaconteur::GetUuidForNameAndLockResult *) 0 ;
  boost::shared_ptr< RobotRaconteur::NodeDirectoriesFD > *result = 0 ;
  
  arg1 = (RobotRaconteur::GetUuidForNameAndLockResult *)jarg1; 
  result = (boost::shared_ptr< RobotRaconteur::NodeDirectoriesFD > *) & ((arg1)->fd);
  jresult = *result ? new boost::shared_ptr< RobotRaconteur::NodeDirectoriesFD >(*result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_GetUuidForNameAndLockResult() {
  void * jresult ;
  RobotRaconteur::GetUuidForNameAndLockResult *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::GetUuidForNameAndLockResult *)new RobotRaconteur::GetUuidForNameAndLockResult();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_GetUuidForNameAndLockResult(void * jarg1) {
  RobotRaconteur::GetUuidForNameAndLockResult *arg1 = (RobotRaconteur::GetUuidForNameAndLockResult *) 0 ;
  
  arg1 = (RobotRaconteur::GetUuidForNameAndLockResult *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_GetUuidForNameAndLock(void * jarg1, char * jarg2, void * jarg3) {
  void * jresult ;
  RobotRaconteur::NodeDirectories *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string > *arg3 = 0 ;
  RobotRaconteur::GetUuidForNameAndLockResult result;
  
  arg1 = (RobotRaconteur::NodeDirectories *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::NodeDirectories const & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (std::vector< std::string > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = RobotRaconteur::GetUuidForNameAndLock((RobotRaconteur::NodeDirectories const &)*arg1,(std::string const &)*arg2,(std::vector< std::string > const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::GetUuidForNameAndLockResult((const RobotRaconteur::GetUuidForNameAndLockResult &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_NodeDirectoriesResourceAlreadyInUse() {
  void * jresult ;
  RobotRaconteur::NodeDirectoriesResourceAlreadyInUse *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::NodeDirectoriesResourceAlreadyInUse *)new RobotRaconteur::NodeDirectoriesResourceAlreadyInUse();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_NodeDirectoriesResourceAlreadyInUse(void * jarg1) {
  RobotRaconteur::NodeDirectoriesResourceAlreadyInUse *arg1 = (RobotRaconteur::NodeDirectoriesResourceAlreadyInUse *) 0 ;
  
  arg1 = (RobotRaconteur::NodeDirectoriesResourceAlreadyInUse *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ClientServiceListenerDirector_objectheapid_set(void * jarg1, int jarg2) {
  ClientServiceListenerDirector *arg1 = (ClientServiceListenerDirector *) 0 ;
  int32_t arg2 ;
  
  arg1 = (ClientServiceListenerDirector *)jarg1; 
  arg2 = (int32_t)jarg2; 
  if (arg1) (arg1)->objectheapid = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_ClientServiceListenerDirector_objectheapid_get(void * jarg1) {
  int jresult ;
  ClientServiceListenerDirector *arg1 = (ClientServiceListenerDirector *) 0 ;
  int32_t result;
  
  arg1 = (ClientServiceListenerDirector *)jarg1; 
  result = (int32_t) ((arg1)->objectheapid);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_ClientServiceListenerDirector() {
  void * jresult ;
  ClientServiceListenerDirector *result = 0 ;
  
  
  try {
    result = (ClientServiceListenerDirector *)new SwigDirector_ClientServiceListenerDirector();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ClientServiceListenerDirector_Callback(void * jarg1, int jarg2) {
  ClientServiceListenerDirector *arg1 = (ClientServiceListenerDirector *) 0 ;
  int32_t arg2 ;
  
  arg1 = (ClientServiceListenerDirector *)jarg1; 
  arg2 = (int32_t)jarg2; 
  
  try {
    (arg1)->Callback(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ClientServiceListenerDirector_CallbackSwigExplicitClientServiceListenerDirector(void * jarg1, int jarg2) {
  ClientServiceListenerDirector *arg1 = (ClientServiceListenerDirector *) 0 ;
  int32_t arg2 ;
  
  arg1 = (ClientServiceListenerDirector *)jarg1; 
  arg2 = (int32_t)jarg2; 
  
  try {
    (arg1)->ClientServiceListenerDirector::Callback(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ClientServiceListenerDirector_Callback2(void * jarg1, int jarg2, char * jarg3) {
  ClientServiceListenerDirector *arg1 = (ClientServiceListenerDirector *) 0 ;
  int32_t arg2 ;
  std::string *arg3 = 0 ;
  
  arg1 = (ClientServiceListenerDirector *)jarg1; 
  arg2 = (int32_t)jarg2; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  try {
    (arg1)->Callback2(arg2,(std::string const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ClientServiceListenerDirector_Callback2SwigExplicitClientServiceListenerDirector(void * jarg1, int jarg2, char * jarg3) {
  ClientServiceListenerDirector *arg1 = (ClientServiceListenerDirector *) 0 ;
  int32_t arg2 ;
  std::string *arg3 = 0 ;
  
  arg1 = (ClientServiceListenerDirector *)jarg1; 
  arg2 = (int32_t)jarg2; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  try {
    (arg1)->ClientServiceListenerDirector::Callback2(arg2,(std::string const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_ClientServiceListenerDirector(void * jarg1) {
  ClientServiceListenerDirector *arg1 = (ClientServiceListenerDirector *) 0 ;
  
  arg1 = (ClientServiceListenerDirector *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_ClientServiceListenerDirector_director_connect(void *objarg, SwigDirector_ClientServiceListenerDirector::SWIG_Callback0_t callback0, SwigDirector_ClientServiceListenerDirector::SWIG_Callback1_t callback1) {
  ClientServiceListenerDirector *obj = (ClientServiceListenerDirector *)objarg;
  SwigDirector_ClientServiceListenerDirector *director = static_cast<SwigDirector_ClientServiceListenerDirector *>(obj);
  director->swig_connect_director(callback0, callback1);
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode_RegisterTransport(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::Transport > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::Transport > tempnull2 ;
  uint32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::Transport > *)jarg2 : &tempnull2; 
  
  try {
    result = (uint32_t)(arg1)->RegisterTransport((boost::shared_ptr< RobotRaconteur::Transport > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__GetRequestTimeout(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  uint32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (uint32_t)(arg1)->GetRequestTimeout();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__SetRequestTimeout(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  uint32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (uint32_t)jarg2; 
  
  try {
    (arg1)->SetRequestTimeout(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__GetTransportInactivityTimeout(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  uint32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (uint32_t)(arg1)->GetTransportInactivityTimeout();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__SetTransportInactivityTimeout(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  uint32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (uint32_t)jarg2; 
  
  try {
    (arg1)->SetTransportInactivityTimeout(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__GetEndpointInactivityTimeout(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  uint32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (uint32_t)(arg1)->GetEndpointInactivityTimeout();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__SetEndpointInactivityTimeout(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  uint32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (uint32_t)jarg2; 
  
  try {
    (arg1)->SetEndpointInactivityTimeout(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__GetMemoryMaxTransferSize(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  uint32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (uint32_t)(arg1)->GetMemoryMaxTransferSize();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__SetMemoryMaxTransferSize(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  uint32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (uint32_t)jarg2; 
  
  try {
    (arg1)->SetMemoryMaxTransferSize(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__GetNodeDiscoveryMaxCacheCount(void * jarg1) {
  unsigned int jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  uint32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (uint32_t)(arg1)->GetNodeDiscoveryMaxCacheCount();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__SetNodeDiscoveryMaxCacheCount(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  uint32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (uint32_t)jarg2; 
  
  try {
    (arg1)->SetNodeDiscoveryMaxCacheCount(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode_UnregisterServiceType(void * jarg1, char * jarg2) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->UnregisterServiceType((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__ConnectService__SWIG_0(void * jarg1, char * jarg2, char * jarg3, void * jarg4, void * jarg5, char * jarg6) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > arg4 ;
  ClientServiceListenerDirector *arg5 = (ClientServiceListenerDirector *) 0 ;
  std::string *arg6 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementData > *smartarg4 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  // intrusive_ptr by value
  smartarg4 = *(boost::shared_ptr<  RobotRaconteur::MessageElementData >**)&jarg4;
  if (smartarg4) {
    arg4 = boost::intrusive_ptr<  RobotRaconteur::MessageElementData >(smartarg4->get(), true);
  }
  
  arg5 = (ClientServiceListenerDirector *)jarg5; 
  if (!jarg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg6_str(jarg6);
  arg6 = &arg6_str; 
  
  try {
    result = RobotRaconteur_RobotRaconteurNode_ConnectService__SWIG_0(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5,(std::string const &)*arg6);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceStub >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__ConnectService__SWIG_1(void * jarg1, char * jarg2, char * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > arg4 ;
  ClientServiceListenerDirector *arg5 = (ClientServiceListenerDirector *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementData > *smartarg4 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  // intrusive_ptr by value
  smartarg4 = *(boost::shared_ptr<  RobotRaconteur::MessageElementData >**)&jarg4;
  if (smartarg4) {
    arg4 = boost::intrusive_ptr<  RobotRaconteur::MessageElementData >(smartarg4->get(), true);
  }
  
  arg5 = (ClientServiceListenerDirector *)jarg5; 
  
  try {
    result = RobotRaconteur_RobotRaconteurNode_ConnectService__SWIG_0(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4,arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceStub >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__ConnectService__SWIG_2(void * jarg1, char * jarg2, char * jarg3, void * jarg4) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > arg4 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementData > *smartarg4 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  // intrusive_ptr by value
  smartarg4 = *(boost::shared_ptr<  RobotRaconteur::MessageElementData >**)&jarg4;
  if (smartarg4) {
    arg4 = boost::intrusive_ptr<  RobotRaconteur::MessageElementData >(smartarg4->get(), true);
  }
  
  
  try {
    result = RobotRaconteur_RobotRaconteurNode_ConnectService__SWIG_0(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceStub >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__ConnectService__SWIG_3(void * jarg1, char * jarg2, char * jarg3) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  try {
    result = RobotRaconteur_RobotRaconteurNode_ConnectService__SWIG_0(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceStub >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__ConnectService__SWIG_4(void * jarg1, char * jarg2) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = RobotRaconteur_RobotRaconteurNode_ConnectService__SWIG_0(arg1,(std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceStub >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__ConnectService__SWIG_5(void * jarg1, void * jarg2, char * jarg3, void * jarg4, void * jarg5, char * jarg6) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > arg4 ;
  ClientServiceListenerDirector *arg5 = (ClientServiceListenerDirector *) 0 ;
  std::string *arg6 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementData > *smartarg4 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< std::string > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  // intrusive_ptr by value
  smartarg4 = *(boost::shared_ptr<  RobotRaconteur::MessageElementData >**)&jarg4;
  if (smartarg4) {
    arg4 = boost::intrusive_ptr<  RobotRaconteur::MessageElementData >(smartarg4->get(), true);
  }
  
  arg5 = (ClientServiceListenerDirector *)jarg5; 
  if (!jarg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg6_str(jarg6);
  arg6 = &arg6_str; 
  
  try {
    result = RobotRaconteur_RobotRaconteurNode_ConnectService__SWIG_5(arg1,(std::vector< std::string > const &)*arg2,(std::string const &)*arg3,arg4,arg5,(std::string const &)*arg6);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceStub >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__ConnectService__SWIG_6(void * jarg1, void * jarg2, char * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > arg4 ;
  ClientServiceListenerDirector *arg5 = (ClientServiceListenerDirector *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementData > *smartarg4 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< std::string > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  // intrusive_ptr by value
  smartarg4 = *(boost::shared_ptr<  RobotRaconteur::MessageElementData >**)&jarg4;
  if (smartarg4) {
    arg4 = boost::intrusive_ptr<  RobotRaconteur::MessageElementData >(smartarg4->get(), true);
  }
  
  arg5 = (ClientServiceListenerDirector *)jarg5; 
  
  try {
    result = RobotRaconteur_RobotRaconteurNode_ConnectService__SWIG_5(arg1,(std::vector< std::string > const &)*arg2,(std::string const &)*arg3,arg4,arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceStub >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__ConnectService__SWIG_7(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > arg4 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::MessageElementData > *smartarg4 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< std::string > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  // intrusive_ptr by value
  smartarg4 = *(boost::shared_ptr<  RobotRaconteur::MessageElementData >**)&jarg4;
  if (smartarg4) {
    arg4 = boost::intrusive_ptr<  RobotRaconteur::MessageElementData >(smartarg4->get(), true);
  }
  
  
  try {
    result = RobotRaconteur_RobotRaconteurNode_ConnectService__SWIG_5(arg1,(std::vector< std::string > const &)*arg2,(std::string const &)*arg3,arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceStub >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__ConnectService__SWIG_8(void * jarg1, void * jarg2, char * jarg3) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< std::string > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  try {
    result = RobotRaconteur_RobotRaconteurNode_ConnectService__SWIG_5(arg1,(std::vector< std::string > const &)*arg2,(std::string const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceStub >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__ConnectService__SWIG_9(void * jarg1, void * jarg2) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< std::string > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = RobotRaconteur_RobotRaconteurNode_ConnectService__SWIG_5(arg1,(std::vector< std::string > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::WrappedServiceStub >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__AsyncConnectService__SWIG_0(void * jarg1, char * jarg2, char * jarg3, void * jarg4, void * jarg5, char * jarg6, int jarg7, void * jarg8, int jarg9) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > *arg4 = 0 ;
  ClientServiceListenerDirector *arg5 = (ClientServiceListenerDirector *) 0 ;
  std::string *arg6 = 0 ;
  int32_t arg7 ;
  RobotRaconteur::AsyncStubReturnDirector *arg8 = (RobotRaconteur::AsyncStubReturnDirector *) 0 ;
  int32_t arg9 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > tempnull4 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > temp4 ;
  boost::shared_ptr< RobotRaconteur::MessageElementData > *smartarg4 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  // intrusive_ptr by reference
  if ( jarg4 ) {
    smartarg4 = *(boost::shared_ptr<  RobotRaconteur::MessageElementData >**)&jarg4;
    temp4 = boost::intrusive_ptr<  RobotRaconteur::MessageElementData >(smartarg4->get(), true);
    arg4 = &temp4;
  } else {
    arg4 = &tempnull4;
  }
  
  arg5 = (ClientServiceListenerDirector *)jarg5; 
  if (!jarg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg6_str(jarg6);
  arg6 = &arg6_str; 
  arg7 = (int32_t)jarg7; 
  arg8 = (RobotRaconteur::AsyncStubReturnDirector *)jarg8; 
  arg9 = (int32_t)jarg9; 
  
  try {
    RobotRaconteur_RobotRaconteurNode_AsyncConnectService__SWIG_0(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(boost::intrusive_ptr< RobotRaconteur::MessageElementData > const &)*arg4,arg5,(std::string const &)*arg6,arg7,arg8,arg9);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__AsyncConnectService__SWIG_1(void * jarg1, void * jarg2, char * jarg3, void * jarg4, void * jarg5, char * jarg6, int jarg7, void * jarg8, int jarg9) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > *arg4 = 0 ;
  ClientServiceListenerDirector *arg5 = (ClientServiceListenerDirector *) 0 ;
  std::string *arg6 = 0 ;
  int32_t arg7 ;
  RobotRaconteur::AsyncStubReturnDirector *arg8 = (RobotRaconteur::AsyncStubReturnDirector *) 0 ;
  int32_t arg9 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > tempnull4 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElementData > temp4 ;
  boost::shared_ptr< RobotRaconteur::MessageElementData > *smartarg4 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< std::string > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return ;
  } 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  // intrusive_ptr by reference
  if ( jarg4 ) {
    smartarg4 = *(boost::shared_ptr<  RobotRaconteur::MessageElementData >**)&jarg4;
    temp4 = boost::intrusive_ptr<  RobotRaconteur::MessageElementData >(smartarg4->get(), true);
    arg4 = &temp4;
  } else {
    arg4 = &tempnull4;
  }
  
  arg5 = (ClientServiceListenerDirector *)jarg5; 
  if (!jarg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg6_str(jarg6);
  arg6 = &arg6_str; 
  arg7 = (int32_t)jarg7; 
  arg8 = (RobotRaconteur::AsyncStubReturnDirector *)jarg8; 
  arg9 = (int32_t)jarg9; 
  
  try {
    RobotRaconteur_RobotRaconteurNode_AsyncConnectService__SWIG_1(arg1,(std::vector< std::string > const &)*arg2,(std::string const &)*arg3,(boost::intrusive_ptr< RobotRaconteur::MessageElementData > const &)*arg4,arg5,(std::string const &)*arg6,arg7,arg8,arg9);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__DisconnectService(void * jarg1, void * jarg2) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *)jarg2 : &tempnull2; 
  
  try {
    RobotRaconteur_RobotRaconteurNode_DisconnectService(arg1,(boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__AsyncDisconnectService(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *arg2 = 0 ;
  RobotRaconteur::AsyncVoidNoErrReturnDirector *arg3 = (RobotRaconteur::AsyncVoidNoErrReturnDirector *) 0 ;
  int32_t arg4 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *)jarg2 : &tempnull2; 
  arg3 = (RobotRaconteur::AsyncVoidNoErrReturnDirector *)jarg3; 
  arg4 = (int32_t)jarg4; 
  
  try {
    RobotRaconteur_RobotRaconteurNode_AsyncDisconnectService(arg1,(boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &)*arg2,arg3,arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode_SelectRemoteNodeURL(void * jarg1) {
  char * jresult ;
  std::vector< std::string > *arg1 = 0 ;
  std::string result;
  
  arg1 = (std::vector< std::string > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = RobotRaconteur::RobotRaconteurNode::SelectRemoteNodeURL((std::vector< std::string > const &)*arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__RegisterServiceType(void * jarg1, void * jarg2) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::ServiceDefinition > *)jarg2 : &tempnull2; 
  
  try {
    RobotRaconteur_RobotRaconteurNode_RegisterServiceType(arg1,(boost::shared_ptr< RobotRaconteur::ServiceDefinition > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__RegisterServiceTypes(void * jarg1, void * jarg2) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > const & type is null", 0);
    return ;
  } 
  
  try {
    RobotRaconteur_RobotRaconteurNode_RegisterServiceTypes(arg1,(std::vector< boost::shared_ptr< RobotRaconteur::ServiceDefinition > > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__GetServiceType(void * jarg1, char * jarg2) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = RobotRaconteur_RobotRaconteurNode_GetServiceType(arg1,(std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::ServiceDefinition >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__GetPulledServiceType(void * jarg1, void * jarg2, char * jarg3) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::RRObject > *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RRObject > tempnull2 ;
  boost::shared_ptr< RobotRaconteur::ServiceDefinition > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::RRObject > *)jarg2 : &tempnull2; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  try {
    result = RobotRaconteur_RobotRaconteurNode_GetPulledServiceType(arg1,(boost::shared_ptr< RobotRaconteur::RRObject > const &)*arg2,(std::string const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::ServiceDefinition >(result) : 0; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode_IsServiceTypeRegistered(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (bool)(arg1)->IsServiceTypeRegistered((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__GetRegisteredServiceTypes(void * jarg1) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  std::vector< std::string > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetRegisteredServiceTypes();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< std::string >((const std::vector< std::string > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__GetPulledServiceTypes(void * jarg1, void * jarg2) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::RRObject > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RRObject > tempnull2 ;
  std::vector< std::string > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::RRObject > *)jarg2 : &tempnull2; 
  
  try {
    result = (arg1)->GetPulledServiceTypes((boost::shared_ptr< RobotRaconteur::RRObject > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new std::vector< std::string >((const std::vector< std::string > &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__get_s() {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > result;
  
  
  try {
    result = RobotRaconteur::RobotRaconteurNode::sp();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::RobotRaconteurNode >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__Shutdown(void * jarg1) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->Shutdown();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__RequestObjectLock(void * jarg1, void * jarg2, int jarg3) {
  char * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *arg2 = 0 ;
  RobotRaconteur::RobotRaconteurObjectLockFlags arg3 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > tempnull2 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *)jarg2 : &tempnull2; 
  arg3 = (RobotRaconteur::RobotRaconteurObjectLockFlags)jarg3; 
  
  try {
    result = RobotRaconteur_RobotRaconteurNode_RequestObjectLock(arg1,(boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &)*arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__ReleaseObjectLock(void * jarg1, void * jarg2) {
  char * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > tempnull2 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *)jarg2 : &tempnull2; 
  
  try {
    result = RobotRaconteur_RobotRaconteurNode_ReleaseObjectLock(arg1,(boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__MonitorEnter__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *arg2 = 0 ;
  int32_t arg3 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *)jarg2 : &tempnull2; 
  arg3 = (int32_t)jarg3; 
  
  try {
    RobotRaconteur_RobotRaconteurNode_MonitorEnter__SWIG_0(arg1,(boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &)*arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__MonitorEnter__SWIG_1(void * jarg1, void * jarg2) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *)jarg2 : &tempnull2; 
  
  try {
    RobotRaconteur_RobotRaconteurNode_MonitorEnter__SWIG_0(arg1,(boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__MonitorExit(void * jarg1, void * jarg2) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *)jarg2 : &tempnull2; 
  
  try {
    RobotRaconteur_RobotRaconteurNode_MonitorExit(arg1,(boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT int64_t SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__NowUTC(void * jarg1) {
  int64_t jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::posix_time::ptime result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->NowUTC();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  {
    {
      boost::posix_time::time_duration ptime_diff = (result - boost::posix_time::ptime(boost::gregorian::date(1970,1,1),boost::posix_time::time_duration(0,0,0)));
      jresult=ptime_diff.total_microseconds()*10;
    }
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__NowTimeSpec(void * jarg1) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  RobotRaconteur::TimeSpec result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->NowTimeSpec();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::TimeSpec((const RobotRaconteur::TimeSpec &)result); 
  return jresult;
}


SWIGEXPORT int64_t SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__NowNodeTime(void * jarg1) {
  int64_t jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::posix_time::ptime result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->NowNodeTime();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  {
    {
      boost::posix_time::time_duration ptime_diff = (result - boost::posix_time::ptime(boost::gregorian::date(1970,1,1),boost::posix_time::time_duration(0,0,0)));
      jresult=ptime_diff.total_microseconds()*10;
    }
  }
  return jresult;
}


SWIGEXPORT int64_t SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__NodeSyncTimeUTC(void * jarg1) {
  int64_t jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::posix_time::ptime result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->NodeSyncTimeUTC();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  {
    {
      boost::posix_time::time_duration ptime_diff = (result - boost::posix_time::ptime(boost::gregorian::date(1970,1,1),boost::posix_time::time_duration(0,0,0)));
      jresult=ptime_diff.total_microseconds()*10;
    }
  }
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__NodeSyncTimeSpec(void * jarg1) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  RobotRaconteur::TimeSpec result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->NodeSyncTimeSpec();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::TimeSpec((const RobotRaconteur::TimeSpec &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__AsyncRequestObjectLock(void * jarg1, void * jarg2, int jarg3, int jarg4, void * jarg5, int jarg6) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *arg2 = 0 ;
  RobotRaconteur::RobotRaconteurObjectLockFlags arg3 ;
  int32_t arg4 ;
  RobotRaconteur::AsyncStringReturnDirector *arg5 = (RobotRaconteur::AsyncStringReturnDirector *) 0 ;
  int32_t arg6 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *)jarg2 : &tempnull2; 
  arg3 = (RobotRaconteur::RobotRaconteurObjectLockFlags)jarg3; 
  arg4 = (int32_t)jarg4; 
  arg5 = (RobotRaconteur::AsyncStringReturnDirector *)jarg5; 
  arg6 = (int32_t)jarg6; 
  
  try {
    RobotRaconteur_RobotRaconteurNode_AsyncRequestObjectLock(arg1,(boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &)*arg2,arg3,arg4,arg5,arg6);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__AsyncReleaseObjectLock(void * jarg1, void * jarg2, int jarg3, void * jarg4, int jarg5) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *arg2 = 0 ;
  int32_t arg3 ;
  RobotRaconteur::AsyncStringReturnDirector *arg4 = (RobotRaconteur::AsyncStringReturnDirector *) 0 ;
  int32_t arg5 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *)jarg2 : &tempnull2; 
  arg3 = (int32_t)jarg3; 
  arg4 = (RobotRaconteur::AsyncStringReturnDirector *)jarg4; 
  arg5 = (int32_t)jarg5; 
  
  try {
    RobotRaconteur_RobotRaconteurNode_AsyncReleaseObjectLock(arg1,(boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &)*arg2,arg3,arg4,arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__GetServiceAttributes(void * jarg1, void * jarg2) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > tempnull2 ;
  boost::intrusive_ptr< RobotRaconteur::MessageElement > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *)jarg2 : &tempnull2; 
  
  try {
    result = RobotRaconteur_RobotRaconteurNode_GetServiceAttributes(arg1,(boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  if (result) {
    intrusive_ptr_add_ref((&result)->get());
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = new boost::shared_ptr<  RobotRaconteur::MessageElement >((&result)->get(), SWIG_intrusive_deleter<  RobotRaconteur::MessageElement >());
  } else {
    *(boost::shared_ptr<  RobotRaconteur::MessageElement > **)&jresult = 0;
  }
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__GetServiceNodeID(void * jarg1, void * jarg2) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > tempnull2 ;
  RobotRaconteur::NodeID result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *)jarg2 : &tempnull2; 
  
  try {
    result = RobotRaconteur_RobotRaconteurNode_GetServiceNodeID(arg1,(boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::NodeID((const RobotRaconteur::NodeID &)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__GetServiceNodeName(void * jarg1, void * jarg2) {
  char * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > tempnull2 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *)jarg2 : &tempnull2; 
  
  try {
    result = RobotRaconteur_RobotRaconteurNode_GetServiceNodeName(arg1,(boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__GetServiceName(void * jarg1, void * jarg2) {
  char * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > tempnull2 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *)jarg2 : &tempnull2; 
  
  try {
    result = RobotRaconteur_RobotRaconteurNode_GetServiceName(arg1,(boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__GetObjectServicePath(void * jarg1, void * jarg2) {
  char * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > tempnull2 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *)jarg2 : &tempnull2; 
  
  try {
    result = RobotRaconteur_RobotRaconteurNode_GetObjectServicePath(arg1,(boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__GetObjectType(void * jarg1, void * jarg2) {
  char * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > tempnull2 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *)jarg2 : &tempnull2; 
  
  try {
    result = RobotRaconteur_RobotRaconteurNode_GetObjectType(arg1,(boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__RegisterService__SWIG_0(void * jarg1, char * jarg2, char * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::RRObject > *arg4 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServiceSecurityPolicy > arg5 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RRObject > tempnull4 ;
  boost::shared_ptr< RobotRaconteur::ServerContext > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  arg4 = jarg4 ? (boost::shared_ptr< RobotRaconteur::RRObject > *)jarg4 : &tempnull4; 
  if (jarg5) arg5 = *(boost::shared_ptr< RobotRaconteur::ServiceSecurityPolicy > *)jarg5; 
  
  try {
    result = (arg1)->RegisterService((std::string const &)*arg2,(std::string const &)*arg3,(boost::shared_ptr< RobotRaconteur::RRObject > const &)*arg4,arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::ServerContext >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__RegisterService__SWIG_1(void * jarg1, char * jarg2, char * jarg3, void * jarg4) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::RRObject > *arg4 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RRObject > tempnull4 ;
  boost::shared_ptr< RobotRaconteur::ServerContext > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  arg4 = jarg4 ? (boost::shared_ptr< RobotRaconteur::RRObject > *)jarg4 : &tempnull4; 
  
  try {
    result = (arg1)->RegisterService((std::string const &)*arg2,(std::string const &)*arg3,(boost::shared_ptr< RobotRaconteur::RRObject > const &)*arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::ServerContext >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode_CloseService(void * jarg1, char * jarg2) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->CloseService((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__NodeID(void * jarg1) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  RobotRaconteur::NodeID result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->NodeID();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::NodeID((const RobotRaconteur::NodeID &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__SetNodeID(void * jarg1, void * jarg2) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  RobotRaconteur::NodeID arg2 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  RobotRaconteur::NodeID const *argp2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  argp2 = (RobotRaconteur::NodeID *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null RobotRaconteur::NodeID const", 0);
    return ;
  }
  arg2 = *argp2; 
  
  try {
    (arg1)->SetNodeID(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__NodeName(void * jarg1) {
  char * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->NodeName();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__SetNodeName(void * jarg1, char * jarg2) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    (arg1)->SetNodeName((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__GetThreadPoolCount(void * jarg1) {
  int jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  int32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (int32_t)(arg1)->GetThreadPoolCount();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__SetThreadPoolCount(void * jarg1, int jarg2) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  int32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (int32_t)jarg2; 
  
  try {
    (arg1)->SetThreadPoolCount(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__FindObjectType__SWIG_0(void * jarg1, void * jarg2, char * jarg3) {
  char * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::RRObject > *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RRObject > tempnull2 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::RRObject > *)jarg2 : &tempnull2; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  try {
    result = (arg1)->FindObjectType((boost::shared_ptr< RobotRaconteur::RRObject > const &)*arg2,(std::string const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__FindObjectType__SWIG_1(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
  char * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::RRObject > *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::RRObject > tempnull2 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::RRObject > *)jarg2 : &tempnull2; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  if (!jarg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg4_str(jarg4);
  arg4 = &arg4_str; 
  
  try {
    result = (arg1)->FindObjectType((boost::shared_ptr< RobotRaconteur::RRObject > const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__AsyncFindObjectType__SWIG_0(void * jarg1, void * jarg2, char * jarg3, int jarg4, void * jarg5, int jarg6) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *arg2 = 0 ;
  std::string *arg3 = 0 ;
  int32_t arg4 ;
  RobotRaconteur::AsyncStringReturnDirector *arg5 = (RobotRaconteur::AsyncStringReturnDirector *) 0 ;
  int32_t arg6 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *)jarg2 : &tempnull2; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  arg4 = (int32_t)jarg4; 
  arg5 = (RobotRaconteur::AsyncStringReturnDirector *)jarg5; 
  arg6 = (int32_t)jarg6; 
  
  try {
    RobotRaconteur_RobotRaconteurNode_AsyncFindObjectType__SWIG_0(arg1,(boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &)*arg2,(std::string const &)*arg3,arg4,arg5,arg6);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__AsyncFindObjectType__SWIG_1(void * jarg1, void * jarg2, char * jarg3, char * jarg4, int jarg5, void * jarg6, int jarg7) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  int32_t arg5 ;
  RobotRaconteur::AsyncStringReturnDirector *arg6 = (RobotRaconteur::AsyncStringReturnDirector *) 0 ;
  int32_t arg7 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedServiceStub > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *)jarg2 : &tempnull2; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  if (!jarg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg4_str(jarg4);
  arg4 = &arg4_str; 
  arg5 = (int32_t)jarg5; 
  arg6 = (RobotRaconteur::AsyncStringReturnDirector *)jarg6; 
  arg7 = (int32_t)jarg7; 
  
  try {
    RobotRaconteur_RobotRaconteurNode_AsyncFindObjectType__SWIG_1(arg1,(boost::shared_ptr< RobotRaconteur::WrappedServiceStub > const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5,arg6,arg7);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__SetExceptionHandler(void * jarg1, void * jarg2, int jarg3) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  RobotRaconteur::AsyncVoidReturnDirector *arg2 = (RobotRaconteur::AsyncVoidReturnDirector *) 0 ;
  int32_t arg3 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::AsyncVoidReturnDirector *)jarg2; 
  arg3 = (int32_t)jarg3; 
  
  try {
    RobotRaconteur_RobotRaconteurNode_SetExceptionHandler(arg1,arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__ClearExceptionHandler(void * jarg1) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    RobotRaconteur_RobotRaconteurNode_ClearExceptionHandler(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode_Sleep(void * jarg1, int32_t jarg2) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::posix_time::time_duration *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::posix_time::time_duration tmpDur2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  {
    tmpDur2=boost::posix_time::milliseconds(jarg2);
    arg2=&tmpDur2;
  }
  
  try {
    (arg1)->Sleep((boost::posix_time::time_duration const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__CreateTimer(void * jarg1, int32_t jarg2, unsigned int jarg3, void * jarg4, int jarg5) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::posix_time::time_duration *arg2 = 0 ;
  bool arg3 ;
  RobotRaconteur::AsyncTimerEventReturnDirector *arg4 = (RobotRaconteur::AsyncTimerEventReturnDirector *) 0 ;
  int32_t arg5 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::posix_time::time_duration tmpDur2 ;
  boost::shared_ptr< RobotRaconteur::Timer > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  {
    tmpDur2=boost::posix_time::milliseconds(jarg2);
    arg2=&tmpDur2;
  }
  arg3 = jarg3 ? true : false; 
  arg4 = (RobotRaconteur::AsyncTimerEventReturnDirector *)jarg4; 
  arg5 = (int32_t)jarg5; 
  
  try {
    result = RobotRaconteur_RobotRaconteurNode_CreateTimer(arg1,(boost::posix_time::time_duration const &)*arg2,arg3,arg4,arg5);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::Timer >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode_CreateRate(void * jarg1, double jarg2) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  double arg2 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::Rate > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (double)jarg2; 
  
  try {
    result = (arg1)->CreateRate(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::Rate >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode_CreateAutoResetEvent(void * jarg1) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::AutoResetEvent > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->CreateAutoResetEvent();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::AutoResetEvent >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__PostToThreadPool(void * jarg1, void * jarg2, int jarg3) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  RobotRaconteur::AsyncVoidNoErrReturnDirector *arg2 = (RobotRaconteur::AsyncVoidNoErrReturnDirector *) 0 ;
  int32_t arg3 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::AsyncVoidNoErrReturnDirector *)jarg2; 
  arg3 = (int32_t)jarg3; 
  
  try {
    RobotRaconteur_RobotRaconteurNode_PostToThreadPool(arg1,arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode__GetRobotRaconteurVersion(void * jarg1) {
  char * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetRobotRaconteurVersion();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode_CompareLogLevel(void * jarg1, int jarg2) {
  unsigned int jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  RobotRaconteur::RobotRaconteur_LogLevel arg2 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::RobotRaconteur_LogLevel)jarg2; 
  
  try {
    result = (bool)(arg1)->CompareLogLevel(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode_LogMessage(void * jarg1, int jarg2, char * jarg3) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  RobotRaconteur::RobotRaconteur_LogLevel arg2 ;
  std::string *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::RobotRaconteur_LogLevel)jarg2; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  try {
    (arg1)->LogMessage(arg2,(std::string const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode_LogRecord(void * jarg1, void * jarg2) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  RobotRaconteur::RRLogRecord *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::RRLogRecord *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::RRLogRecord const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->LogRecord((RobotRaconteur::RRLogRecord const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode_GetLogLevel(void * jarg1) {
  int jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  RobotRaconteur::RobotRaconteur_LogLevel result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (RobotRaconteur::RobotRaconteur_LogLevel)(arg1)->GetLogLevel();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode_SetLogLevel(void * jarg1, int jarg2) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  RobotRaconteur::RobotRaconteur_LogLevel arg2 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::RobotRaconteur_LogLevel)jarg2; 
  
  try {
    (arg1)->SetLogLevel(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode_SetLogLevelFromString(void * jarg1, char * jarg2) {
  int jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  RobotRaconteur::RobotRaconteur_LogLevel result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (RobotRaconteur::RobotRaconteur_LogLevel)(arg1)->SetLogLevelFromString((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode_SetLogLevelFromEnvVariable__SWIG_0(void * jarg1, char * jarg2) {
  int jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  RobotRaconteur::RobotRaconteur_LogLevel result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (RobotRaconteur::RobotRaconteur_LogLevel)(arg1)->SetLogLevelFromEnvVariable((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode_SetLogLevelFromEnvVariable__SWIG_1(void * jarg1) {
  int jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  RobotRaconteur::RobotRaconteur_LogLevel result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (RobotRaconteur::RobotRaconteur_LogLevel)(arg1)->SetLogLevelFromEnvVariable();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (int)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode_GetLogRecordHandler(void * jarg1) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::LogRecordHandler > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetLogRecordHandler();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::LogRecordHandler >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode_SetLogRecordHandler(void * jarg1, void * jarg2) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::LogRecordHandler > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::LogRecordHandler > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::LogRecordHandler > *)jarg2 : &tempnull2; 
  
  try {
    (arg1)->SetLogRecordHandler((boost::shared_ptr< RobotRaconteur::LogRecordHandler > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode_CheckConnection(void * jarg1, unsigned int jarg2) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  uint32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (uint32_t)jarg2; 
  
  try {
    (arg1)->CheckConnection(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode_GetNodeDirectories(void * jarg1) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  RobotRaconteur::NodeDirectories result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetNodeDirectories();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = new RobotRaconteur::NodeDirectories((const RobotRaconteur::NodeDirectories &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RobotRaconteurNode_SetNodeDirectories(void * jarg1, void * jarg2) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  RobotRaconteur::NodeDirectories *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (RobotRaconteur::NodeDirectories *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "RobotRaconteur::NodeDirectories const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->SetNodeDirectories((RobotRaconteur::NodeDirectories const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_RobotRaconteurNode(void * jarg1) {
  RobotRaconteur::RobotRaconteurNode *arg1 = (RobotRaconteur::RobotRaconteurNode *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNode > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNode *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_CommandLineConfigParser__SWIG_0(unsigned int jarg1, char * jarg2) {
  void * jresult ;
  uint32_t arg1 ;
  std::string *arg2 = 0 ;
  RobotRaconteur::CommandLineConfigParser *result = 0 ;
  
  arg1 = (uint32_t)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (RobotRaconteur::CommandLineConfigParser *)new RobotRaconteur::CommandLineConfigParser(arg1,(std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::CommandLineConfigParser >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_CommandLineConfigParser__SWIG_1(unsigned int jarg1) {
  void * jresult ;
  uint32_t arg1 ;
  RobotRaconteur::CommandLineConfigParser *result = 0 ;
  
  arg1 = (uint32_t)jarg1; 
  
  try {
    result = (RobotRaconteur::CommandLineConfigParser *)new RobotRaconteur::CommandLineConfigParser(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::CommandLineConfigParser >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_CommandLineConfigParser_SetDefaults(void * jarg1, char * jarg2, unsigned short jarg3, unsigned int jarg4) {
  RobotRaconteur::CommandLineConfigParser *arg1 = (RobotRaconteur::CommandLineConfigParser *) 0 ;
  std::string *arg2 = 0 ;
  uint16_t arg3 ;
  uint32_t arg4 ;
  boost::shared_ptr< RobotRaconteur::CommandLineConfigParser > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::CommandLineConfigParser > *)jarg1;
  arg1 = (RobotRaconteur::CommandLineConfigParser *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (uint16_t)jarg3; 
  arg4 = (uint32_t)jarg4; 
  
  try {
    (arg1)->SetDefaults((std::string const &)*arg2,arg3,arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_CommandLineConfigParser_AddStringOption(void * jarg1, char * jarg2, char * jarg3) {
  RobotRaconteur::CommandLineConfigParser *arg1 = (RobotRaconteur::CommandLineConfigParser *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::CommandLineConfigParser > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::CommandLineConfigParser > *)jarg1;
  arg1 = (RobotRaconteur::CommandLineConfigParser *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  try {
    (arg1)->AddStringOption((std::string const &)*arg2,(std::string const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_CommandLineConfigParser_AddBoolOption(void * jarg1, char * jarg2, char * jarg3) {
  RobotRaconteur::CommandLineConfigParser *arg1 = (RobotRaconteur::CommandLineConfigParser *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::CommandLineConfigParser > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::CommandLineConfigParser > *)jarg1;
  arg1 = (RobotRaconteur::CommandLineConfigParser *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  try {
    (arg1)->AddBoolOption((std::string const &)*arg2,(std::string const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_CommandLineConfigParser_AddIntOption(void * jarg1, char * jarg2, char * jarg3) {
  RobotRaconteur::CommandLineConfigParser *arg1 = (RobotRaconteur::CommandLineConfigParser *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::CommandLineConfigParser > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::CommandLineConfigParser > *)jarg1;
  arg1 = (RobotRaconteur::CommandLineConfigParser *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  try {
    (arg1)->AddIntOption((std::string const &)*arg2,(std::string const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_CommandLineConfigParser__ParseCommandLine(void * jarg1, void * jarg2) {
  RobotRaconteur::CommandLineConfigParser *arg1 = (RobotRaconteur::CommandLineConfigParser *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::CommandLineConfigParser > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::CommandLineConfigParser > *)jarg1;
  arg1 = (RobotRaconteur::CommandLineConfigParser *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (std::vector< std::string > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return ;
  } 
  
  try {
    (arg1)->ParseCommandLine((std::vector< std::string > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_CommandLineConfigParser_GetOptionOrDefaultAsString__SWIG_0(void * jarg1, char * jarg2) {
  char * jresult ;
  RobotRaconteur::CommandLineConfigParser *arg1 = (RobotRaconteur::CommandLineConfigParser *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::CommandLineConfigParser > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::CommandLineConfigParser > *)jarg1;
  arg1 = (RobotRaconteur::CommandLineConfigParser *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (arg1)->GetOptionOrDefaultAsString((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_RobotRaconteur_CommandLineConfigParser_GetOptionOrDefaultAsString__SWIG_1(void * jarg1, char * jarg2, char * jarg3) {
  char * jresult ;
  RobotRaconteur::CommandLineConfigParser *arg1 = (RobotRaconteur::CommandLineConfigParser *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  boost::shared_ptr< RobotRaconteur::CommandLineConfigParser > *smartarg1 = 0 ;
  std::string result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::CommandLineConfigParser > *)jarg1;
  arg1 = (RobotRaconteur::CommandLineConfigParser *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  
  try {
    result = (arg1)->GetOptionOrDefaultAsString((std::string const &)*arg2,(std::string const &)*arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_CommandLineConfigParser_GetOptionOrDefaultAsBool__SWIG_0(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  RobotRaconteur::CommandLineConfigParser *arg1 = (RobotRaconteur::CommandLineConfigParser *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::CommandLineConfigParser > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::CommandLineConfigParser > *)jarg1;
  arg1 = (RobotRaconteur::CommandLineConfigParser *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (bool)(arg1)->GetOptionOrDefaultAsBool((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_CommandLineConfigParser_GetOptionOrDefaultAsBool__SWIG_1(void * jarg1, char * jarg2, unsigned int jarg3) {
  unsigned int jresult ;
  RobotRaconteur::CommandLineConfigParser *arg1 = (RobotRaconteur::CommandLineConfigParser *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  boost::shared_ptr< RobotRaconteur::CommandLineConfigParser > *smartarg1 = 0 ;
  bool result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::CommandLineConfigParser > *)jarg1;
  arg1 = (RobotRaconteur::CommandLineConfigParser *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = jarg3 ? true : false; 
  
  try {
    result = (bool)(arg1)->GetOptionOrDefaultAsBool((std::string const &)*arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_CommandLineConfigParser_GetOptionOrDefaultAsInt__SWIG_0(void * jarg1, char * jarg2) {
  int jresult ;
  RobotRaconteur::CommandLineConfigParser *arg1 = (RobotRaconteur::CommandLineConfigParser *) 0 ;
  std::string *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::CommandLineConfigParser > *smartarg1 = 0 ;
  int32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::CommandLineConfigParser > *)jarg1;
  arg1 = (RobotRaconteur::CommandLineConfigParser *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  try {
    result = (int32_t)(arg1)->GetOptionOrDefaultAsInt((std::string const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_RobotRaconteur_CommandLineConfigParser_GetOptionOrDefaultAsInt__SWIG_1(void * jarg1, char * jarg2, int jarg3) {
  int jresult ;
  RobotRaconteur::CommandLineConfigParser *arg1 = (RobotRaconteur::CommandLineConfigParser *) 0 ;
  std::string *arg2 = 0 ;
  int32_t arg3 ;
  boost::shared_ptr< RobotRaconteur::CommandLineConfigParser > *smartarg1 = 0 ;
  int32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::CommandLineConfigParser > *)jarg1;
  arg1 = (RobotRaconteur::CommandLineConfigParser *)(smartarg1 ? smartarg1->get() : 0); 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (int32_t)jarg3; 
  
  try {
    result = (int32_t)(arg1)->GetOptionOrDefaultAsInt((std::string const &)*arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_CommandLineConfigParser(void * jarg1) {
  RobotRaconteur::CommandLineConfigParser *arg1 = (RobotRaconteur::CommandLineConfigParser *) 0 ;
  boost::shared_ptr< RobotRaconteur::CommandLineConfigParser > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::CommandLineConfigParser > *)jarg1;
  arg1 = (RobotRaconteur::CommandLineConfigParser *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedRobotRaconteurNodeSetup_GetLocalTransport(void * jarg1) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNodeSetup *arg1 = (RobotRaconteur::RobotRaconteurNodeSetup *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNodeSetup > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::LocalTransport > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNodeSetup > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNodeSetup *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetLocalTransport();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::LocalTransport >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedRobotRaconteurNodeSetup_GetIntraTransport(void * jarg1) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNodeSetup *arg1 = (RobotRaconteur::RobotRaconteurNodeSetup *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNodeSetup > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::IntraTransport > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNodeSetup > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNodeSetup *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetIntraTransport();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::IntraTransport >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedRobotRaconteurNodeSetup_GetTcpTransport(void * jarg1) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNodeSetup *arg1 = (RobotRaconteur::RobotRaconteurNodeSetup *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNodeSetup > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::TcpTransport > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNodeSetup > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNodeSetup *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetTcpTransport();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::TcpTransport >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedRobotRaconteurNodeSetup_GetHardwareTransport(void * jarg1) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNodeSetup *arg1 = (RobotRaconteur::RobotRaconteurNodeSetup *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNodeSetup > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::HardwareTransport > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNodeSetup > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNodeSetup *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetHardwareTransport();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::HardwareTransport >(result) : 0; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_WrappedRobotRaconteurNodeSetup_GetCommandLineConfig(void * jarg1) {
  void * jresult ;
  RobotRaconteur::RobotRaconteurNodeSetup *arg1 = (RobotRaconteur::RobotRaconteurNodeSetup *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNodeSetup > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::CommandLineConfigParser > result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNodeSetup > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNodeSetup *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    result = (arg1)->GetCommandLineConfig();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result ? new boost::shared_ptr< RobotRaconteur::CommandLineConfigParser >(result) : 0; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_WrappedRobotRaconteurNodeSetup_ReleaseNode(void * jarg1) {
  RobotRaconteur::RobotRaconteurNodeSetup *arg1 = (RobotRaconteur::RobotRaconteurNodeSetup *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNodeSetup > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNodeSetup > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNodeSetup *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->ReleaseNode();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_WrappedRobotRaconteurNodeSetup(void * jarg1) {
  RobotRaconteur::RobotRaconteurNodeSetup *arg1 = (RobotRaconteur::RobotRaconteurNodeSetup *) 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNodeSetup > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::RobotRaconteurNodeSetup > *)jarg1;
  arg1 = (RobotRaconteur::RobotRaconteurNodeSetup *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedRobotRaconteurNodeSetup__SWIG_0(void * jarg1, char * jarg2, unsigned short jarg3, unsigned int jarg4) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  uint16_t arg3 ;
  uint32_t arg4 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  RobotRaconteur::RobotRaconteurNodeSetup *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (uint16_t)jarg3; 
  arg4 = (uint32_t)jarg4; 
  
  try {
    result = (RobotRaconteur::RobotRaconteurNodeSetup *)new_RobotRaconteur_RobotRaconteurNodeSetup__SWIG_0((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1,(std::string const &)*arg2,arg3,arg4);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::RobotRaconteurNodeSetup >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedRobotRaconteurNodeSetup__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::CommandLineConfigParser > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  boost::shared_ptr< RobotRaconteur::CommandLineConfigParser > tempnull2 ;
  RobotRaconteur::RobotRaconteurNodeSetup *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::CommandLineConfigParser > *)jarg2 : &tempnull2; 
  
  try {
    result = (RobotRaconteur::RobotRaconteurNodeSetup *)new_RobotRaconteur_RobotRaconteurNodeSetup__SWIG_1((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1,(boost::shared_ptr< RobotRaconteur::CommandLineConfigParser > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::RobotRaconteurNodeSetup >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_WrappedRobotRaconteurNodeSetup__SWIG_2(void * jarg1, char * jarg2, unsigned short jarg3, unsigned int jarg4, unsigned int jarg5, void * jarg6) {
  void * jresult ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  uint16_t arg3 ;
  uint32_t arg4 ;
  uint32_t arg5 ;
  std::vector< std::string > *arg6 = 0 ;
  boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > tempnull1 ;
  RobotRaconteur::RobotRaconteurNodeSetup *result = 0 ;
  
  arg1 = jarg1 ? (boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > *)jarg1 : &tempnull1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (uint16_t)jarg3; 
  arg4 = (uint32_t)jarg4; 
  arg5 = (uint32_t)jarg5; 
  arg6 = (std::vector< std::string > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  
  try {
    result = (RobotRaconteur::RobotRaconteurNodeSetup *)new_RobotRaconteur_RobotRaconteurNodeSetup__SWIG_2((boost::shared_ptr< RobotRaconteur::RobotRaconteurNode > const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(std::vector< std::string > const &)*arg6);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::RobotRaconteurNodeSetup >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_BroadcastDownsampler() {
  void * jresult ;
  RobotRaconteur::BroadcastDownsampler *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::BroadcastDownsampler *)new RobotRaconteur::BroadcastDownsampler();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  
  jresult = result ? new boost::shared_ptr<  RobotRaconteur::BroadcastDownsampler >(result SWIG_NO_NULL_DELETER_1) : 0;
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_BroadcastDownsampler__Init__SWIG_0(void * jarg1, void * jarg2, unsigned int jarg3) {
  RobotRaconteur::BroadcastDownsampler *arg1 = (RobotRaconteur::BroadcastDownsampler *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServerContext > *arg2 = 0 ;
  uint32_t arg3 ;
  boost::shared_ptr< RobotRaconteur::BroadcastDownsampler > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServerContext > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::BroadcastDownsampler > *)jarg1;
  arg1 = (RobotRaconteur::BroadcastDownsampler *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::ServerContext > *)jarg2 : &tempnull2; 
  arg3 = (uint32_t)jarg3; 
  
  try {
    (arg1)->Init((boost::shared_ptr< RobotRaconteur::ServerContext > const &)*arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_BroadcastDownsampler__Init__SWIG_1(void * jarg1, void * jarg2) {
  RobotRaconteur::BroadcastDownsampler *arg1 = (RobotRaconteur::BroadcastDownsampler *) 0 ;
  boost::shared_ptr< RobotRaconteur::ServerContext > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::BroadcastDownsampler > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::ServerContext > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::BroadcastDownsampler > *)jarg1;
  arg1 = (RobotRaconteur::BroadcastDownsampler *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::ServerContext > *)jarg2 : &tempnull2; 
  
  try {
    (arg1)->Init((boost::shared_ptr< RobotRaconteur::ServerContext > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_RobotRaconteur_BroadcastDownsampler_GetClientDownsample(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ;
  RobotRaconteur::BroadcastDownsampler *arg1 = (RobotRaconteur::BroadcastDownsampler *) 0 ;
  uint32_t arg2 ;
  boost::shared_ptr< RobotRaconteur::BroadcastDownsampler > *smartarg1 = 0 ;
  uint32_t result;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::BroadcastDownsampler > *)jarg1;
  arg1 = (RobotRaconteur::BroadcastDownsampler *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (uint32_t)jarg2; 
  
  try {
    result = (uint32_t)(arg1)->GetClientDownsample(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_BroadcastDownsampler_SetClientDownsample(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
  RobotRaconteur::BroadcastDownsampler *arg1 = (RobotRaconteur::BroadcastDownsampler *) 0 ;
  uint32_t arg2 ;
  uint32_t arg3 ;
  boost::shared_ptr< RobotRaconteur::BroadcastDownsampler > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::BroadcastDownsampler > *)jarg1;
  arg1 = (RobotRaconteur::BroadcastDownsampler *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = (uint32_t)jarg2; 
  arg3 = (uint32_t)jarg3; 
  
  try {
    (arg1)->SetClientDownsample(arg2,arg3);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_BroadcastDownsampler_BeginStep(void * jarg1) {
  RobotRaconteur::BroadcastDownsampler *arg1 = (RobotRaconteur::BroadcastDownsampler *) 0 ;
  boost::shared_ptr< RobotRaconteur::BroadcastDownsampler > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::BroadcastDownsampler > *)jarg1;
  arg1 = (RobotRaconteur::BroadcastDownsampler *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->BeginStep();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_BroadcastDownsampler_EndStep(void * jarg1) {
  RobotRaconteur::BroadcastDownsampler *arg1 = (RobotRaconteur::BroadcastDownsampler *) 0 ;
  boost::shared_ptr< RobotRaconteur::BroadcastDownsampler > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::BroadcastDownsampler > *)jarg1;
  arg1 = (RobotRaconteur::BroadcastDownsampler *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (arg1)->EndStep();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_BroadcastDownsampler__AddPipeBroadcaster(void * jarg1, void * jarg2) {
  RobotRaconteur::BroadcastDownsampler *arg1 = (RobotRaconteur::BroadcastDownsampler *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeBroadcaster > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::BroadcastDownsampler > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedPipeBroadcaster > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::BroadcastDownsampler > *)jarg1;
  arg1 = (RobotRaconteur::BroadcastDownsampler *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedPipeBroadcaster > *)jarg2 : &tempnull2; 
  
  try {
    (arg1)->AddPipeBroadcaster((boost::shared_ptr< RobotRaconteur::WrappedPipeBroadcaster > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_BroadcastDownsampler__AddWireBroadcaster(void * jarg1, void * jarg2) {
  RobotRaconteur::BroadcastDownsampler *arg1 = (RobotRaconteur::BroadcastDownsampler *) 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireBroadcaster > *arg2 = 0 ;
  boost::shared_ptr< RobotRaconteur::BroadcastDownsampler > *smartarg1 = 0 ;
  boost::shared_ptr< RobotRaconteur::WrappedWireBroadcaster > tempnull2 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::BroadcastDownsampler > *)jarg1;
  arg1 = (RobotRaconteur::BroadcastDownsampler *)(smartarg1 ? smartarg1->get() : 0); 
  arg2 = jarg2 ? (boost::shared_ptr< RobotRaconteur::WrappedWireBroadcaster > *)jarg2 : &tempnull2; 
  
  try {
    (arg1)->AddWireBroadcaster((boost::shared_ptr< RobotRaconteur::WrappedWireBroadcaster > const &)*arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_BroadcastDownsampler(void * jarg1) {
  RobotRaconteur::BroadcastDownsampler *arg1 = (RobotRaconteur::BroadcastDownsampler *) 0 ;
  boost::shared_ptr< RobotRaconteur::BroadcastDownsampler > *smartarg1 = 0 ;
  
  
  smartarg1 = (boost::shared_ptr<  RobotRaconteur::BroadcastDownsampler > *)jarg1;
  arg1 = (RobotRaconteur::BroadcastDownsampler *)(smartarg1 ? smartarg1->get() : 0); 
  
  try {
    (void)arg1; delete smartarg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RRNativeObjectHeapSupport_Set_Support(void * jarg1) {
  RobotRaconteur::RRNativeObjectHeapSupport *arg1 = (RobotRaconteur::RRNativeObjectHeapSupport *) 0 ;
  
  arg1 = (RobotRaconteur::RRNativeObjectHeapSupport *)jarg1; 
  
  try {
    RobotRaconteur::RRNativeObjectHeapSupport::Set_Support(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RRNativeObjectHeapSupport_DeleteObject_i(void * jarg1, int jarg2) {
  RobotRaconteur::RRNativeObjectHeapSupport *arg1 = (RobotRaconteur::RRNativeObjectHeapSupport *) 0 ;
  int32_t arg2 ;
  
  arg1 = (RobotRaconteur::RRNativeObjectHeapSupport *)jarg1; 
  arg2 = (int32_t)jarg2; 
  
  try {
    (arg1)->DeleteObject_i(arg2);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RRNativeObjectHeapSupport_DeleteObject(int jarg1) {
  int32_t arg1 ;
  
  arg1 = (int32_t)jarg1; 
  
  try {
    RobotRaconteur::RRNativeObjectHeapSupport::DeleteObject(arg1);
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_delete_RRNativeObjectHeapSupport(void * jarg1) {
  RobotRaconteur::RRNativeObjectHeapSupport *arg1 = (RobotRaconteur::RRNativeObjectHeapSupport *) 0 ;
  
  arg1 = (RobotRaconteur::RRNativeObjectHeapSupport *)jarg1; 
  
  try {
    delete arg1;
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return ;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return ;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_RobotRaconteur_new_RRNativeObjectHeapSupport() {
  void * jresult ;
  RobotRaconteur::RRNativeObjectHeapSupport *result = 0 ;
  
  
  try {
    result = (RobotRaconteur::RRNativeObjectHeapSupport *)new SwigDirector_RRNativeObjectHeapSupport();
  } catch (RobotRaconteurException& e)
  {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    if (robotRaconteurExceptionHelper!=NULL)
    {
      RobotRaconteur::HandlerErrorInfo err3(e);
      robotRaconteurExceptionHelper->SetRobotRaconteurException(err3);
      return 0;
    }
    else
    {
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
      return 0;
    }
    
    
  } catch (std::exception& e) {
    RR_SHARED_PTR<RobotRaconteurNode> default_node = RobotRaconteurNode::weak_sp().lock();
    if (default_node)
    {
      ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(default_node, Default, -1, "Exception raised in C++, passing to wrapped language: " << e.what());
    }
    SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, e.what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_RobotRaconteur_RRNativeObjectHeapSupport_director_connect(void *objarg, SwigDirector_RRNativeObjectHeapSupport::SWIG_Callback0_t callback0) {
  RobotRaconteur::RRNativeObjectHeapSupport *obj = (RobotRaconteur::RRNativeObjectHeapSupport *)objarg;
  SwigDirector_RRNativeObjectHeapSupport *director = static_cast<SwigDirector_RRNativeObjectHeapSupport *>(obj);
  director->swig_connect_director(callback0);
}


SWIGEXPORT boost::shared_ptr< RobotRaconteur::RRValue > * SWIGSTDCALL CSharp_RobotRaconteur_MessageElementData_SWIGSmartPtrUpcast(boost::shared_ptr< RobotRaconteur::MessageElementData > *jarg1) {
    return jarg1 ? new boost::shared_ptr< RobotRaconteur::RRValue >(*jarg1) : 0;
}

SWIGEXPORT boost::shared_ptr< RobotRaconteur::MessageElementData > * SWIGSTDCALL CSharp_RobotRaconteur_RRBaseArray_SWIGSmartPtrUpcast(boost::shared_ptr< RobotRaconteur::RRBaseArray > *jarg1) {
    return jarg1 ? new boost::shared_ptr< RobotRaconteur::MessageElementData >(*jarg1) : 0;
}

SWIGEXPORT boost::shared_ptr< RobotRaconteur::MemberDefinition > * SWIGSTDCALL CSharp_RobotRaconteur_PropertyDefinition_SWIGSmartPtrUpcast(boost::shared_ptr< RobotRaconteur::PropertyDefinition > *jarg1) {
    return jarg1 ? new boost::shared_ptr< RobotRaconteur::MemberDefinition >(*jarg1) : 0;
}

SWIGEXPORT boost::shared_ptr< RobotRaconteur::MemberDefinition > * SWIGSTDCALL CSharp_RobotRaconteur_FunctionDefinition_SWIGSmartPtrUpcast(boost::shared_ptr< RobotRaconteur::FunctionDefinition > *jarg1) {
    return jarg1 ? new boost::shared_ptr< RobotRaconteur::MemberDefinition >(*jarg1) : 0;
}

SWIGEXPORT boost::shared_ptr< RobotRaconteur::MemberDefinition > * SWIGSTDCALL CSharp_RobotRaconteur_EventDefinition_SWIGSmartPtrUpcast(boost::shared_ptr< RobotRaconteur::EventDefinition > *jarg1) {
    return jarg1 ? new boost::shared_ptr< RobotRaconteur::MemberDefinition >(*jarg1) : 0;
}

SWIGEXPORT boost::shared_ptr< RobotRaconteur::MemberDefinition > * SWIGSTDCALL CSharp_RobotRaconteur_ObjRefDefinition_SWIGSmartPtrUpcast(boost::shared_ptr< RobotRaconteur::ObjRefDefinition > *jarg1) {
    return jarg1 ? new boost::shared_ptr< RobotRaconteur::MemberDefinition >(*jarg1) : 0;
}

SWIGEXPORT boost::shared_ptr< RobotRaconteur::MemberDefinition > * SWIGSTDCALL CSharp_RobotRaconteur_PipeDefinition_SWIGSmartPtrUpcast(boost::shared_ptr< RobotRaconteur::PipeDefinition > *jarg1) {
    return jarg1 ? new boost::shared_ptr< RobotRaconteur::MemberDefinition >(*jarg1) : 0;
}

SWIGEXPORT boost::shared_ptr< RobotRaconteur::MemberDefinition > * SWIGSTDCALL CSharp_RobotRaconteur_CallbackDefinition_SWIGSmartPtrUpcast(boost::shared_ptr< RobotRaconteur::CallbackDefinition > *jarg1) {
    return jarg1 ? new boost::shared_ptr< RobotRaconteur::MemberDefinition >(*jarg1) : 0;
}

SWIGEXPORT boost::shared_ptr< RobotRaconteur::MemberDefinition > * SWIGSTDCALL CSharp_RobotRaconteur_WireDefinition_SWIGSmartPtrUpcast(boost::shared_ptr< RobotRaconteur::WireDefinition > *jarg1) {
    return jarg1 ? new boost::shared_ptr< RobotRaconteur::MemberDefinition >(*jarg1) : 0;
}

SWIGEXPORT boost::shared_ptr< RobotRaconteur::MemberDefinition > * SWIGSTDCALL CSharp_RobotRaconteur_MemoryDefinition_SWIGSmartPtrUpcast(boost::shared_ptr< RobotRaconteur::MemoryDefinition > *jarg1) {
    return jarg1 ? new boost::shared_ptr< RobotRaconteur::MemberDefinition >(*jarg1) : 0;
}

SWIGEXPORT boost::shared_ptr< RobotRaconteur::RRValue > * SWIGSTDCALL CSharp_RobotRaconteur_Message_SWIGSmartPtrUpcast(boost::shared_ptr< RobotRaconteur::Message > *jarg1) {
    return jarg1 ? new boost::shared_ptr< RobotRaconteur::RRValue >(*jarg1) : 0;
}

SWIGEXPORT boost::shared_ptr< RobotRaconteur::RRValue > * SWIGSTDCALL CSharp_RobotRaconteur_MessageHeader_SWIGSmartPtrUpcast(boost::shared_ptr< RobotRaconteur::MessageHeader > *jarg1) {
    return jarg1 ? new boost::shared_ptr< RobotRaconteur::RRValue >(*jarg1) : 0;
}

SWIGEXPORT boost::shared_ptr< RobotRaconteur::RRValue > * SWIGSTDCALL CSharp_RobotRaconteur_MessageEntry_SWIGSmartPtrUpcast(boost::shared_ptr< RobotRaconteur::MessageEntry > *jarg1) {
    return jarg1 ? new boost::shared_ptr< RobotRaconteur::RRValue >(*jarg1) : 0;
}

SWIGEXPORT boost::shared_ptr< RobotRaconteur::RRValue > * SWIGSTDCALL CSharp_RobotRaconteur_MessageElement_SWIGSmartPtrUpcast(boost::shared_ptr< RobotRaconteur::MessageElement > *jarg1) {
    return jarg1 ? new boost::shared_ptr< RobotRaconteur::RRValue >(*jarg1) : 0;
}

SWIGEXPORT boost::shared_ptr< RobotRaconteur::MessageElementData > * SWIGSTDCALL CSharp_RobotRaconteur_MessageElementNestedElementList_SWIGSmartPtrUpcast(boost::shared_ptr< RobotRaconteur::MessageElementNestedElementList > *jarg1) {
    return jarg1 ? new boost::shared_ptr< RobotRaconteur::MessageElementData >(*jarg1) : 0;
}

SWIGEXPORT boost::shared_ptr< RobotRaconteur::Transport > * SWIGSTDCALL CSharp_RobotRaconteur_TcpTransport_SWIGSmartPtrUpcast(boost::shared_ptr< RobotRaconteur::TcpTransport > *jarg1) {
    return jarg1 ? new boost::shared_ptr< RobotRaconteur::Transport >(*jarg1) : 0;
}

SWIGEXPORT boost::shared_ptr< RobotRaconteur::Transport > * SWIGSTDCALL CSharp_RobotRaconteur_LocalTransport_SWIGSmartPtrUpcast(boost::shared_ptr< RobotRaconteur::LocalTransport > *jarg1) {
    return jarg1 ? new boost::shared_ptr< RobotRaconteur::Transport >(*jarg1) : 0;
}

SWIGEXPORT boost::shared_ptr< RobotRaconteur::Transport > * SWIGSTDCALL CSharp_RobotRaconteur_HardwareTransport_SWIGSmartPtrUpcast(boost::shared_ptr< RobotRaconteur::HardwareTransport > *jarg1) {
    return jarg1 ? new boost::shared_ptr< RobotRaconteur::Transport >(*jarg1) : 0;
}

SWIGEXPORT boost::shared_ptr< RobotRaconteur::Transport > * SWIGSTDCALL CSharp_RobotRaconteur_IntraTransport_SWIGSmartPtrUpcast(boost::shared_ptr< RobotRaconteur::IntraTransport > *jarg1) {
    return jarg1 ? new boost::shared_ptr< RobotRaconteur::Transport >(*jarg1) : 0;
}

SWIGEXPORT boost::shared_ptr< RobotRaconteur::Timer > * SWIGSTDCALL CSharp_RobotRaconteur_WallTimer_SWIGSmartPtrUpcast(boost::shared_ptr< RobotRaconteur::WallTimer > *jarg1) {
    return jarg1 ? new boost::shared_ptr< RobotRaconteur::Timer >(*jarg1) : 0;
}

SWIGEXPORT boost::shared_ptr< RobotRaconteur::Rate > * SWIGSTDCALL CSharp_RobotRaconteur_WallRate_SWIGSmartPtrUpcast(boost::shared_ptr< RobotRaconteur::WallRate > *jarg1) {
    return jarg1 ? new boost::shared_ptr< RobotRaconteur::Rate >(*jarg1) : 0;
}

SWIGEXPORT boost::shared_ptr< RobotRaconteur::RRObject > * SWIGSTDCALL CSharp_RobotRaconteur_WrappedServiceStub_SWIGSmartPtrUpcast(boost::shared_ptr< RobotRaconteur::WrappedServiceStub > *jarg1) {
    return jarg1 ? new boost::shared_ptr< RobotRaconteur::RRObject >(*jarg1) : 0;
}

SWIGEXPORT boost::shared_ptr< RobotRaconteur::RRObject > * SWIGSTDCALL CSharp_RobotRaconteur_WrappedRRObject_SWIGSmartPtrUpcast(boost::shared_ptr< RobotRaconteur::WrappedRRObject > *jarg1) {
    return jarg1 ? new boost::shared_ptr< RobotRaconteur::RRObject >(*jarg1) : 0;
}

SWIGEXPORT boost::shared_ptr< RobotRaconteur::UserAuthenticator > * SWIGSTDCALL CSharp_RobotRaconteur_PasswordFileUserAuthenticator_SWIGSmartPtrUpcast(boost::shared_ptr< RobotRaconteur::PasswordFileUserAuthenticator > *jarg1) {
    return jarg1 ? new boost::shared_ptr< RobotRaconteur::UserAuthenticator >(*jarg1) : 0;
}

SWIGEXPORT boost::shared_ptr< RobotRaconteur::UserAuthenticator > * SWIGSTDCALL CSharp_RobotRaconteur_WrappedUserAuthenticator_SWIGSmartPtrUpcast(boost::shared_ptr< RobotRaconteur::WrappedUserAuthenticator > *jarg1) {
    return jarg1 ? new boost::shared_ptr< RobotRaconteur::UserAuthenticator >(*jarg1) : 0;
}

SWIGEXPORT boost::shared_ptr< RobotRaconteur::LogRecordHandler > * SWIGSTDCALL CSharp_RobotRaconteur_UserLogRecordHandlerBase_SWIGSmartPtrUpcast(boost::shared_ptr< RobotRaconteur::UserLogRecordHandlerBase > *jarg1) {
    return jarg1 ? new boost::shared_ptr< RobotRaconteur::LogRecordHandler >(*jarg1) : 0;
}

#ifdef __cplusplus
}
#endif

