StdUtils_wrap.cxx

#include "StdAfx.h"

using namespace StdUtils;

/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 3.0.0
 *
 * 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.
 * ----------------------------------------------------------------------------- */

#define SWIGCSHARP
#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 (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#  ifndef GCC_HASCLASSVISIBILITY
#    define GCC_HASCLASSVISIBILITY
#  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



#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_StdUtils_VC10D(
                                                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_StdUtils_VC10D(
                                                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_StdUtils_VC10D(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.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) {
    }
  };
}




#include <stdexcept>


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


#include <string>

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::string 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< int > *new_std_vector_Sl_int_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_int_Sg__getitemcopy(std::vector< int > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN int const &std_vector_Sl_int_Sg__getitem(std::vector< int > *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_int_Sg__setitem(std::vector< int > *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_int_Sg__AddRange(std::vector< int > *self,std::vector< int > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< int > *std_vector_Sl_int_Sg__GetRange(std::vector< int > *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_int_Sg__Insert(std::vector< int > *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_int_Sg__InsertRange(std::vector< int > *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_int_Sg__RemoveAt(std::vector< int > *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_int_Sg__RemoveRange(std::vector< int > *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_int_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_int_Sg__Reverse__SWIG_0(std::vector< int > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_int_Sg__Reverse__SWIG_1(std::vector< int > *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_int_Sg__SetRange(std::vector< int > *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_int_Sg__Contains(std::vector< int > *self,int const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_int_Sg__IndexOf(std::vector< int > *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_int_Sg__LastIndexOf(std::vector< int > *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_int_Sg__Remove(std::vector< int > *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;
      }


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

#include "StdUtils_wrap.h"


#ifdef __cplusplus
extern "C" {
#endif

SWIGEXPORT void SWIGSTDCALL CSharp_vector_String_Clear(void * jarg1) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT void SWIGSTDCALL CSharp_vector_String_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; 
  (arg1)->push_back((std::string const &)*arg2);
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_vector_String_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; 
  result = ((std::vector< std::string > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_vector_String_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; 
  result = ((std::vector< std::string > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_vector_String_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; 
  (arg1)->reserve(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_vector_String__SWIG_0() {
  void * jresult ;
  std::vector< std::string > *result = 0 ;
  
  result = (std::vector< std::string > *)new std::vector< std::string >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_vector_String__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;
  } 
  result = (std::vector< std::string > *)new std::vector< std::string >((std::vector< std::string > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_vector_String__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< std::string > *result = 0 ;
  
  arg1 = (int)jarg1; 
  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;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_vector_String_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 {
    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;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_vector_String_getitem(void * jarg1, int jarg2) {
  char * jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  std::string *result = 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::string *) &std_vector_Sl_std_string_Sg__getitem(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_vector_String_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 {
    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 ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_vector_String_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 ;
  } 
  std_vector_Sl_std_string_Sg__AddRange(arg1,(std::vector< std::string > const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_vector_String_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 {
    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;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_vector_String_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 {
    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 ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_vector_String_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 {
    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 ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_vector_String_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 {
    std_vector_Sl_std_string_Sg__RemoveAt(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_vector_String_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 {
    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 ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_vector_String_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 {
    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;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_vector_String_Reverse__SWIG_0(void * jarg1) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  std_vector_Sl_std_string_Sg__Reverse__SWIG_0(arg1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_vector_String_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 {
    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 ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_vector_String_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 {
    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 ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_vector_String_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; 
  result = (bool)std_vector_Sl_std_string_Sg__Contains(arg1,(std::string const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_vector_String_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; 
  result = (int)std_vector_Sl_std_string_Sg__IndexOf(arg1,(std::string const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_vector_String_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; 
  result = (int)std_vector_Sl_std_string_Sg__LastIndexOf(arg1,(std::string const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_vector_String_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; 
  result = (bool)std_vector_Sl_std_string_Sg__Remove(arg1,(std::string const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_vector_String(void * jarg1) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_vector_int_Clear(void * jarg1) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT void SWIGSTDCALL CSharp_vector_int_Add(void * jarg1, int jarg2) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int *arg2 = 0 ;
  int temp2 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  (arg1)->push_back((int const &)*arg2);
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_vector_int_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::size_type result;
  
  arg1 = (std::vector< int > *)jarg1; 
  result = ((std::vector< int > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_vector_int_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::size_type result;
  
  arg1 = (std::vector< int > *)jarg1; 
  result = ((std::vector< int > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_vector_int_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::size_type arg2 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (std::vector< int >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_vector_int__SWIG_0() {
  void * jresult ;
  std::vector< int > *result = 0 ;
  
  result = (std::vector< int > *)new std::vector< int >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_vector_int__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< int > *arg1 = 0 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (std::vector< int > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< int > *)new std::vector< int >((std::vector< int > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_vector_int__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< int > *)new_std_vector_Sl_int_Sg___SWIG_2(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_vector_int_getitemcopy(void * jarg1, int jarg2) {
  int jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  int result;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (int)std_vector_Sl_int_Sg__getitemcopy(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_vector_int_getitem(void * jarg1, int jarg2) {
  int jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  int *result = 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (int *) &std_vector_Sl_int_Sg__getitem(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = *result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_vector_int_setitem(void * jarg1, int jarg2, int jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  int *arg3 = 0 ;
  int temp3 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (int)jarg3; 
  arg3 = &temp3; 
  try {
    std_vector_Sl_int_Sg__setitem(arg1,arg2,(int const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_vector_int_AddRange(void * jarg1, void * jarg2) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int > *arg2 = 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (std::vector< int > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_int_Sg__AddRange(arg1,(std::vector< int > const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_vector_int_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< int > *)std_vector_Sl_int_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;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_vector_int_Insert(void * jarg1, int jarg2, int jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  int *arg3 = 0 ;
  int temp3 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (int)jarg3; 
  arg3 = &temp3; 
  try {
    std_vector_Sl_int_Sg__Insert(arg1,arg2,(int const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_vector_int_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  std::vector< int > *arg3 = 0 ;
  
  arg1 = (std::vector< int > *)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 {
    std_vector_Sl_int_Sg__InsertRange(arg1,arg2,(std::vector< int > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_vector_int_RemoveAt(void * jarg1, int jarg2) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_int_Sg__RemoveAt(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_vector_int_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_int_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 ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_vector_int_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 {
    result = (std::vector< int > *)std_vector_Sl_int_Sg__Repeat((int const &)*arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_vector_int_Reverse__SWIG_0(void * jarg1) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  std_vector_Sl_int_Sg__Reverse__SWIG_0(arg1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_vector_int_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_int_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 ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_vector_int_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  std::vector< int > *arg3 = 0 ;
  
  arg1 = (std::vector< int > *)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 {
    std_vector_Sl_int_Sg__SetRange(arg1,arg2,(std::vector< int > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_vector_int_Contains(void * jarg1, int jarg2) {
  unsigned int jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int *arg2 = 0 ;
  int temp2 ;
  bool result;
  
  arg1 = (std::vector< int > *)jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  result = (bool)std_vector_Sl_int_Sg__Contains(arg1,(int const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_vector_int_IndexOf(void * jarg1, int jarg2) {
  int jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int *arg2 = 0 ;
  int temp2 ;
  int result;
  
  arg1 = (std::vector< int > *)jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  result = (int)std_vector_Sl_int_Sg__IndexOf(arg1,(int const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_vector_int_LastIndexOf(void * jarg1, int jarg2) {
  int jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int *arg2 = 0 ;
  int temp2 ;
  int result;
  
  arg1 = (std::vector< int > *)jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  result = (int)std_vector_Sl_int_Sg__LastIndexOf(arg1,(int const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_vector_int_Remove(void * jarg1, int jarg2) {
  unsigned int jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int *arg2 = 0 ;
  int temp2 ;
  bool result;
  
  arg1 = (std::vector< int > *)jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  result = (bool)std_vector_Sl_int_Sg__Remove(arg1,(int const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_vector_int(void * jarg1) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdPoint_int_x_set(void * jarg1, int jarg2) {
  CStdPoint< int > *arg1 = (CStdPoint< int > *) 0 ;
  int arg2 ;
  
  arg1 = (CStdPoint< int > *)jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->x = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_CStdPoint_int_x_get(void * jarg1) {
  int jresult ;
  CStdPoint< int > *arg1 = (CStdPoint< int > *) 0 ;
  int result;
  
  arg1 = (CStdPoint< int > *)jarg1; 
  result = (int) ((arg1)->x);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdPoint_int_y_set(void * jarg1, int jarg2) {
  CStdPoint< int > *arg1 = (CStdPoint< int > *) 0 ;
  int arg2 ;
  
  arg1 = (CStdPoint< int > *)jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->y = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_CStdPoint_int_y_get(void * jarg1) {
  int jresult ;
  CStdPoint< int > *arg1 = (CStdPoint< int > *) 0 ;
  int result;
  
  arg1 = (CStdPoint< int > *)jarg1; 
  result = (int) ((arg1)->y);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdPoint_int_z_set(void * jarg1, int jarg2) {
  CStdPoint< int > *arg1 = (CStdPoint< int > *) 0 ;
  int arg2 ;
  
  arg1 = (CStdPoint< int > *)jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->z = arg2;
}


SWIGEXPORT int SWIGSTDCALL CSharp_CStdPoint_int_z_get(void * jarg1) {
  int jresult ;
  CStdPoint< int > *arg1 = (CStdPoint< int > *) 0 ;
  int result;
  
  arg1 = (CStdPoint< int > *)jarg1; 
  result = (int) ((arg1)->z);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_CStdPoint_int__SWIG_0() {
  void * jresult ;
  CStdPoint< int > *result = 0 ;
  
  result = (CStdPoint< int > *)new CStdPoint< int >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_CStdPoint_int__SWIG_1(int jarg1, int jarg2, int jarg3) {
  void * jresult ;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  CStdPoint< int > *result = 0 ;
  
  arg1 = (int)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  result = (CStdPoint< int > *)new CStdPoint< int >(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdPoint_int_Set(void * jarg1, int jarg2, int jarg3, int jarg4) {
  CStdPoint< int > *arg1 = (CStdPoint< int > *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  
  arg1 = (CStdPoint< int > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  arg4 = (int)jarg4; 
  (arg1)->Set(arg2,arg3,arg4);
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CStdPoint_int_Equal(void * jarg1, void * jarg2, double jarg3) {
  unsigned int jresult ;
  CStdPoint< int > *arg1 = (CStdPoint< int > *) 0 ;
  CStdPoint< int > *arg2 = 0 ;
  double arg3 ;
  bool result;
  
  arg1 = (CStdPoint< int > *)jarg1; 
  arg2 = (CStdPoint< int > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< int > const & type is null", 0);
    return 0;
  } 
  arg3 = (double)jarg3; 
  result = (bool)(arg1)->Equal((CStdPoint< int > const &)*arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_CStdPoint_int_dot(void * jarg1, void * jarg2) {
  float jresult ;
  CStdPoint< int > *arg1 = (CStdPoint< int > *) 0 ;
  CStdPoint< int > *arg2 = 0 ;
  float result;
  
  arg1 = (CStdPoint< int > *)jarg1; 
  arg2 = (CStdPoint< int > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< int > const & type is null", 0);
    return 0;
  } 
  result = (float)(arg1)->dot((CStdPoint< int > const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_CStdPoint_int_Magnitude(void * jarg1) {
  double jresult ;
  CStdPoint< int > *arg1 = (CStdPoint< int > *) 0 ;
  double result;
  
  arg1 = (CStdPoint< int > *)jarg1; 
  result = (double)(arg1)->Magnitude();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdPoint_int_Normalize(void * jarg1) {
  CStdPoint< int > *arg1 = (CStdPoint< int > *) 0 ;
  
  arg1 = (CStdPoint< int > *)jarg1; 
  (arg1)->Normalize();
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdPoint_int_ClearNearZero__SWIG_0(void * jarg1, float jarg2) {
  CStdPoint< int > *arg1 = (CStdPoint< int > *) 0 ;
  float arg2 ;
  
  arg1 = (CStdPoint< int > *)jarg1; 
  arg2 = (float)jarg2; 
  (arg1)->ClearNearZero(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdPoint_int_ClearNearZero__SWIG_1(void * jarg1) {
  CStdPoint< int > *arg1 = (CStdPoint< int > *) 0 ;
  
  arg1 = (CStdPoint< int > *)jarg1; 
  (arg1)->ClearNearZero();
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_CStdPoint_int(void * jarg1) {
  CStdPoint< int > *arg1 = (CStdPoint< int > *) 0 ;
  
  arg1 = (CStdPoint< int > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdPoint_long_x_set(void * jarg1, long jarg2) {
  CStdPoint< long > *arg1 = (CStdPoint< long > *) 0 ;
  long arg2 ;
  
  arg1 = (CStdPoint< long > *)jarg1; 
  arg2 = (long)jarg2; 
  if (arg1) (arg1)->x = arg2;
}


SWIGEXPORT long SWIGSTDCALL CSharp_CStdPoint_long_x_get(void * jarg1) {
  long jresult ;
  CStdPoint< long > *arg1 = (CStdPoint< long > *) 0 ;
  long result;
  
  arg1 = (CStdPoint< long > *)jarg1; 
  result = (long) ((arg1)->x);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdPoint_long_y_set(void * jarg1, long jarg2) {
  CStdPoint< long > *arg1 = (CStdPoint< long > *) 0 ;
  long arg2 ;
  
  arg1 = (CStdPoint< long > *)jarg1; 
  arg2 = (long)jarg2; 
  if (arg1) (arg1)->y = arg2;
}


SWIGEXPORT long SWIGSTDCALL CSharp_CStdPoint_long_y_get(void * jarg1) {
  long jresult ;
  CStdPoint< long > *arg1 = (CStdPoint< long > *) 0 ;
  long result;
  
  arg1 = (CStdPoint< long > *)jarg1; 
  result = (long) ((arg1)->y);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdPoint_long_z_set(void * jarg1, long jarg2) {
  CStdPoint< long > *arg1 = (CStdPoint< long > *) 0 ;
  long arg2 ;
  
  arg1 = (CStdPoint< long > *)jarg1; 
  arg2 = (long)jarg2; 
  if (arg1) (arg1)->z = arg2;
}


SWIGEXPORT long SWIGSTDCALL CSharp_CStdPoint_long_z_get(void * jarg1) {
  long jresult ;
  CStdPoint< long > *arg1 = (CStdPoint< long > *) 0 ;
  long result;
  
  arg1 = (CStdPoint< long > *)jarg1; 
  result = (long) ((arg1)->z);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_CStdPoint_long__SWIG_0() {
  void * jresult ;
  CStdPoint< long > *result = 0 ;
  
  result = (CStdPoint< long > *)new CStdPoint< long >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_CStdPoint_long__SWIG_1(long jarg1, long jarg2, long jarg3) {
  void * jresult ;
  long arg1 ;
  long arg2 ;
  long arg3 ;
  CStdPoint< long > *result = 0 ;
  
  arg1 = (long)jarg1; 
  arg2 = (long)jarg2; 
  arg3 = (long)jarg3; 
  result = (CStdPoint< long > *)new CStdPoint< long >(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdPoint_long_Set(void * jarg1, long jarg2, long jarg3, long jarg4) {
  CStdPoint< long > *arg1 = (CStdPoint< long > *) 0 ;
  long arg2 ;
  long arg3 ;
  long arg4 ;
  
  arg1 = (CStdPoint< long > *)jarg1; 
  arg2 = (long)jarg2; 
  arg3 = (long)jarg3; 
  arg4 = (long)jarg4; 
  (arg1)->Set(arg2,arg3,arg4);
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CStdPoint_long_Equal(void * jarg1, void * jarg2, double jarg3) {
  unsigned int jresult ;
  CStdPoint< long > *arg1 = (CStdPoint< long > *) 0 ;
  CStdPoint< long > *arg2 = 0 ;
  double arg3 ;
  bool result;
  
  arg1 = (CStdPoint< long > *)jarg1; 
  arg2 = (CStdPoint< long > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< long > const & type is null", 0);
    return 0;
  } 
  arg3 = (double)jarg3; 
  result = (bool)(arg1)->Equal((CStdPoint< long > const &)*arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_CStdPoint_long_dot(void * jarg1, void * jarg2) {
  float jresult ;
  CStdPoint< long > *arg1 = (CStdPoint< long > *) 0 ;
  CStdPoint< long > *arg2 = 0 ;
  float result;
  
  arg1 = (CStdPoint< long > *)jarg1; 
  arg2 = (CStdPoint< long > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< long > const & type is null", 0);
    return 0;
  } 
  result = (float)(arg1)->dot((CStdPoint< long > const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_CStdPoint_long_Magnitude(void * jarg1) {
  double jresult ;
  CStdPoint< long > *arg1 = (CStdPoint< long > *) 0 ;
  double result;
  
  arg1 = (CStdPoint< long > *)jarg1; 
  result = (double)(arg1)->Magnitude();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdPoint_long_Normalize(void * jarg1) {
  CStdPoint< long > *arg1 = (CStdPoint< long > *) 0 ;
  
  arg1 = (CStdPoint< long > *)jarg1; 
  (arg1)->Normalize();
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdPoint_long_ClearNearZero__SWIG_0(void * jarg1, float jarg2) {
  CStdPoint< long > *arg1 = (CStdPoint< long > *) 0 ;
  float arg2 ;
  
  arg1 = (CStdPoint< long > *)jarg1; 
  arg2 = (float)jarg2; 
  (arg1)->ClearNearZero(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdPoint_long_ClearNearZero__SWIG_1(void * jarg1) {
  CStdPoint< long > *arg1 = (CStdPoint< long > *) 0 ;
  
  arg1 = (CStdPoint< long > *)jarg1; 
  (arg1)->ClearNearZero();
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_CStdPoint_long(void * jarg1) {
  CStdPoint< long > *arg1 = (CStdPoint< long > *) 0 ;
  
  arg1 = (CStdPoint< long > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdPoint_float_x_set(void * jarg1, float jarg2) {
  CStdPoint< float > *arg1 = (CStdPoint< float > *) 0 ;
  float arg2 ;
  
  arg1 = (CStdPoint< float > *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->x = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_CStdPoint_float_x_get(void * jarg1) {
  float jresult ;
  CStdPoint< float > *arg1 = (CStdPoint< float > *) 0 ;
  float result;
  
  arg1 = (CStdPoint< float > *)jarg1; 
  result = (float) ((arg1)->x);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdPoint_float_y_set(void * jarg1, float jarg2) {
  CStdPoint< float > *arg1 = (CStdPoint< float > *) 0 ;
  float arg2 ;
  
  arg1 = (CStdPoint< float > *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->y = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_CStdPoint_float_y_get(void * jarg1) {
  float jresult ;
  CStdPoint< float > *arg1 = (CStdPoint< float > *) 0 ;
  float result;
  
  arg1 = (CStdPoint< float > *)jarg1; 
  result = (float) ((arg1)->y);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdPoint_float_z_set(void * jarg1, float jarg2) {
  CStdPoint< float > *arg1 = (CStdPoint< float > *) 0 ;
  float arg2 ;
  
  arg1 = (CStdPoint< float > *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->z = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_CStdPoint_float_z_get(void * jarg1) {
  float jresult ;
  CStdPoint< float > *arg1 = (CStdPoint< float > *) 0 ;
  float result;
  
  arg1 = (CStdPoint< float > *)jarg1; 
  result = (float) ((arg1)->z);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_CStdPoint_float__SWIG_0() {
  void * jresult ;
  CStdPoint< float > *result = 0 ;
  
  result = (CStdPoint< float > *)new CStdPoint< float >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_CStdPoint_float__SWIG_1(float jarg1, float jarg2, float jarg3) {
  void * jresult ;
  float arg1 ;
  float arg2 ;
  float arg3 ;
  CStdPoint< float > *result = 0 ;
  
  arg1 = (float)jarg1; 
  arg2 = (float)jarg2; 
  arg3 = (float)jarg3; 
  result = (CStdPoint< float > *)new CStdPoint< float >(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdPoint_float_Set(void * jarg1, float jarg2, float jarg3, float jarg4) {
  CStdPoint< float > *arg1 = (CStdPoint< float > *) 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  
  arg1 = (CStdPoint< float > *)jarg1; 
  arg2 = (float)jarg2; 
  arg3 = (float)jarg3; 
  arg4 = (float)jarg4; 
  (arg1)->Set(arg2,arg3,arg4);
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CStdPoint_float_Equal(void * jarg1, void * jarg2, double jarg3) {
  unsigned int jresult ;
  CStdPoint< float > *arg1 = (CStdPoint< float > *) 0 ;
  CStdPoint< float > *arg2 = 0 ;
  double arg3 ;
  bool result;
  
  arg1 = (CStdPoint< float > *)jarg1; 
  arg2 = (CStdPoint< float > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< float > const & type is null", 0);
    return 0;
  } 
  arg3 = (double)jarg3; 
  result = (bool)(arg1)->Equal((CStdPoint< float > const &)*arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_CStdPoint_float_dot(void * jarg1, void * jarg2) {
  float jresult ;
  CStdPoint< float > *arg1 = (CStdPoint< float > *) 0 ;
  CStdPoint< float > *arg2 = 0 ;
  float result;
  
  arg1 = (CStdPoint< float > *)jarg1; 
  arg2 = (CStdPoint< float > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< float > const & type is null", 0);
    return 0;
  } 
  result = (float)(arg1)->dot((CStdPoint< float > const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_CStdPoint_float_Magnitude(void * jarg1) {
  double jresult ;
  CStdPoint< float > *arg1 = (CStdPoint< float > *) 0 ;
  double result;
  
  arg1 = (CStdPoint< float > *)jarg1; 
  result = (double)(arg1)->Magnitude();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdPoint_float_Normalize(void * jarg1) {
  CStdPoint< float > *arg1 = (CStdPoint< float > *) 0 ;
  
  arg1 = (CStdPoint< float > *)jarg1; 
  (arg1)->Normalize();
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdPoint_float_ClearNearZero__SWIG_0(void * jarg1, float jarg2) {
  CStdPoint< float > *arg1 = (CStdPoint< float > *) 0 ;
  float arg2 ;
  
  arg1 = (CStdPoint< float > *)jarg1; 
  arg2 = (float)jarg2; 
  (arg1)->ClearNearZero(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdPoint_float_ClearNearZero__SWIG_1(void * jarg1) {
  CStdPoint< float > *arg1 = (CStdPoint< float > *) 0 ;
  
  arg1 = (CStdPoint< float > *)jarg1; 
  (arg1)->ClearNearZero();
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_CStdPoint_float(void * jarg1) {
  CStdPoint< float > *arg1 = (CStdPoint< float > *) 0 ;
  
  arg1 = (CStdPoint< float > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdPoint_double_x_set(void * jarg1, double jarg2) {
  CStdPoint< double > *arg1 = (CStdPoint< double > *) 0 ;
  double arg2 ;
  
  arg1 = (CStdPoint< double > *)jarg1; 
  arg2 = (double)jarg2; 
  if (arg1) (arg1)->x = arg2;
}


SWIGEXPORT double SWIGSTDCALL CSharp_CStdPoint_double_x_get(void * jarg1) {
  double jresult ;
  CStdPoint< double > *arg1 = (CStdPoint< double > *) 0 ;
  double result;
  
  arg1 = (CStdPoint< double > *)jarg1; 
  result = (double) ((arg1)->x);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdPoint_double_y_set(void * jarg1, double jarg2) {
  CStdPoint< double > *arg1 = (CStdPoint< double > *) 0 ;
  double arg2 ;
  
  arg1 = (CStdPoint< double > *)jarg1; 
  arg2 = (double)jarg2; 
  if (arg1) (arg1)->y = arg2;
}


SWIGEXPORT double SWIGSTDCALL CSharp_CStdPoint_double_y_get(void * jarg1) {
  double jresult ;
  CStdPoint< double > *arg1 = (CStdPoint< double > *) 0 ;
  double result;
  
  arg1 = (CStdPoint< double > *)jarg1; 
  result = (double) ((arg1)->y);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdPoint_double_z_set(void * jarg1, double jarg2) {
  CStdPoint< double > *arg1 = (CStdPoint< double > *) 0 ;
  double arg2 ;
  
  arg1 = (CStdPoint< double > *)jarg1; 
  arg2 = (double)jarg2; 
  if (arg1) (arg1)->z = arg2;
}


SWIGEXPORT double SWIGSTDCALL CSharp_CStdPoint_double_z_get(void * jarg1) {
  double jresult ;
  CStdPoint< double > *arg1 = (CStdPoint< double > *) 0 ;
  double result;
  
  arg1 = (CStdPoint< double > *)jarg1; 
  result = (double) ((arg1)->z);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_CStdPoint_double__SWIG_0() {
  void * jresult ;
  CStdPoint< double > *result = 0 ;
  
  result = (CStdPoint< double > *)new CStdPoint< double >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_CStdPoint_double__SWIG_1(double jarg1, double jarg2, double jarg3) {
  void * jresult ;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  CStdPoint< double > *result = 0 ;
  
  arg1 = (double)jarg1; 
  arg2 = (double)jarg2; 
  arg3 = (double)jarg3; 
  result = (CStdPoint< double > *)new CStdPoint< double >(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdPoint_double_Set(void * jarg1, double jarg2, double jarg3, double jarg4) {
  CStdPoint< double > *arg1 = (CStdPoint< double > *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  
  arg1 = (CStdPoint< double > *)jarg1; 
  arg2 = (double)jarg2; 
  arg3 = (double)jarg3; 
  arg4 = (double)jarg4; 
  (arg1)->Set(arg2,arg3,arg4);
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CStdPoint_double_Equal(void * jarg1, void * jarg2, double jarg3) {
  unsigned int jresult ;
  CStdPoint< double > *arg1 = (CStdPoint< double > *) 0 ;
  CStdPoint< double > *arg2 = 0 ;
  double arg3 ;
  bool result;
  
  arg1 = (CStdPoint< double > *)jarg1; 
  arg2 = (CStdPoint< double > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< double > const & type is null", 0);
    return 0;
  } 
  arg3 = (double)jarg3; 
  result = (bool)(arg1)->Equal((CStdPoint< double > const &)*arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_CStdPoint_double_dot(void * jarg1, void * jarg2) {
  float jresult ;
  CStdPoint< double > *arg1 = (CStdPoint< double > *) 0 ;
  CStdPoint< double > *arg2 = 0 ;
  float result;
  
  arg1 = (CStdPoint< double > *)jarg1; 
  arg2 = (CStdPoint< double > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< double > const & type is null", 0);
    return 0;
  } 
  result = (float)(arg1)->dot((CStdPoint< double > const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_CStdPoint_double_Magnitude(void * jarg1) {
  double jresult ;
  CStdPoint< double > *arg1 = (CStdPoint< double > *) 0 ;
  double result;
  
  arg1 = (CStdPoint< double > *)jarg1; 
  result = (double)(arg1)->Magnitude();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdPoint_double_Normalize(void * jarg1) {
  CStdPoint< double > *arg1 = (CStdPoint< double > *) 0 ;
  
  arg1 = (CStdPoint< double > *)jarg1; 
  (arg1)->Normalize();
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdPoint_double_ClearNearZero__SWIG_0(void * jarg1, float jarg2) {
  CStdPoint< double > *arg1 = (CStdPoint< double > *) 0 ;
  float arg2 ;
  
  arg1 = (CStdPoint< double > *)jarg1; 
  arg2 = (float)jarg2; 
  (arg1)->ClearNearZero(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdPoint_double_ClearNearZero__SWIG_1(void * jarg1) {
  CStdPoint< double > *arg1 = (CStdPoint< double > *) 0 ;
  
  arg1 = (CStdPoint< double > *)jarg1; 
  (arg1)->ClearNearZero();
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_CStdPoint_double(void * jarg1) {
  CStdPoint< double > *arg1 = (CStdPoint< double > *) 0 ;
  
  arg1 = (CStdPoint< double > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_CStdSerialize() {
  void * jresult ;
  StdUtils::CStdSerialize *result = 0 ;
  
  result = (StdUtils::CStdSerialize *)new StdUtils::CStdSerialize();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_CStdSerialize(void * jarg1) {
  StdUtils::CStdSerialize *arg1 = (StdUtils::CStdSerialize *) 0 ;
  
  arg1 = (StdUtils::CStdSerialize *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_CStdSerialize_Clone(void * jarg1) {
  void * jresult ;
  StdUtils::CStdSerialize *arg1 = (StdUtils::CStdSerialize *) 0 ;
  StdUtils::CStdSerialize *result = 0 ;
  
  arg1 = (StdUtils::CStdSerialize *)jarg1; 
  result = (StdUtils::CStdSerialize *)(arg1)->Clone();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdSerialize_Trace(void * jarg1, void * jarg2) {
  StdUtils::CStdSerialize *arg1 = (StdUtils::CStdSerialize *) 0 ;
  std::ostream *arg2 = 0 ;
  
  arg1 = (StdUtils::CStdSerialize *)jarg1; 
  arg2 = (std::ostream *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::ostream & type is null", 0);
    return ;
  } 
  (arg1)->Trace(*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdSerialize_Load(void * jarg1, void * jarg2) {
  StdUtils::CStdSerialize *arg1 = (StdUtils::CStdSerialize *) 0 ;
  CStdXml *arg2 = 0 ;
  
  arg1 = (StdUtils::CStdSerialize *)jarg1; 
  arg2 = (CStdXml *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdXml & type is null", 0);
    return ;
  } 
  (arg1)->Load(*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdSerialize_Save(void * jarg1, void * jarg2) {
  StdUtils::CStdSerialize *arg1 = (StdUtils::CStdSerialize *) 0 ;
  CStdXml *arg2 = 0 ;
  
  arg1 = (StdUtils::CStdSerialize *)jarg1; 
  arg2 = (CStdXml *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdXml & type is null", 0);
    return ;
  } 
  (arg1)->Save(*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Std_SavePoint__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
  CStdXml *arg1 = 0 ;
  std::string arg2 ;
  CStdPoint< int > *arg3 = 0 ;
  
  arg1 = (CStdXml *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdXml & type is null", 0);
    return ;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (CStdPoint< int > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< int > & type is null", 0);
    return ;
  } 
  StdUtils::Std_SavePoint(*arg1,arg2,*arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Std_SavePoint__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
  CStdXml *arg1 = 0 ;
  std::string arg2 ;
  CStdPoint< long > *arg3 = 0 ;
  
  arg1 = (CStdXml *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdXml & type is null", 0);
    return ;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (CStdPoint< long > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< long > & type is null", 0);
    return ;
  } 
  StdUtils::Std_SavePoint(*arg1,arg2,*arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Std_SavePoint__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
  CStdXml *arg1 = 0 ;
  std::string arg2 ;
  CStdPoint< float > *arg3 = 0 ;
  
  arg1 = (CStdXml *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdXml & type is null", 0);
    return ;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (CStdPoint< float > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< float > & type is null", 0);
    return ;
  } 
  StdUtils::Std_SavePoint(*arg1,arg2,*arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Std_SavePoint__SWIG_3(void * jarg1, char * jarg2, void * jarg3) {
  CStdXml *arg1 = 0 ;
  std::string arg2 ;
  CStdPoint< double > *arg3 = 0 ;
  
  arg1 = (CStdXml *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdXml & type is null", 0);
    return ;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (CStdPoint< double > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< double > & type is null", 0);
    return ;
  } 
  StdUtils::Std_SavePoint(*arg1,arg2,*arg3);
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Std_LoadPoint__SWIG_0(void * jarg1, char * jarg2, void * jarg3, unsigned int jarg4) {
  unsigned int jresult ;
  CStdXml *arg1 = 0 ;
  std::string arg2 ;
  CStdPoint< int > *arg3 = 0 ;
  bool arg4 ;
  bool result;
  
  arg1 = (CStdXml *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdXml & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (CStdPoint< int > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< int > & type is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  result = (bool)StdUtils::Std_LoadPoint(*arg1,arg2,*arg3,arg4);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Std_LoadPoint__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
  unsigned int jresult ;
  CStdXml *arg1 = 0 ;
  std::string arg2 ;
  CStdPoint< int > *arg3 = 0 ;
  bool result;
  
  arg1 = (CStdXml *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdXml & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (CStdPoint< int > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< int > & type is null", 0);
    return 0;
  } 
  result = (bool)StdUtils::Std_LoadPoint(*arg1,arg2,*arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Std_LoadPoint__SWIG_2(void * jarg1, char * jarg2, void * jarg3, unsigned int jarg4) {
  unsigned int jresult ;
  CStdXml *arg1 = 0 ;
  std::string arg2 ;
  CStdPoint< long > *arg3 = 0 ;
  bool arg4 ;
  bool result;
  
  arg1 = (CStdXml *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdXml & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (CStdPoint< long > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< long > & type is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  result = (bool)StdUtils::Std_LoadPoint(*arg1,arg2,*arg3,arg4);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Std_LoadPoint__SWIG_3(void * jarg1, char * jarg2, void * jarg3) {
  unsigned int jresult ;
  CStdXml *arg1 = 0 ;
  std::string arg2 ;
  CStdPoint< long > *arg3 = 0 ;
  bool result;
  
  arg1 = (CStdXml *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdXml & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (CStdPoint< long > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< long > & type is null", 0);
    return 0;
  } 
  result = (bool)StdUtils::Std_LoadPoint(*arg1,arg2,*arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Std_LoadPoint__SWIG_4(void * jarg1, char * jarg2, void * jarg3, unsigned int jarg4) {
  unsigned int jresult ;
  CStdXml *arg1 = 0 ;
  std::string arg2 ;
  CStdPoint< float > *arg3 = 0 ;
  bool arg4 ;
  bool result;
  
  arg1 = (CStdXml *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdXml & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (CStdPoint< float > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< float > & type is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  result = (bool)StdUtils::Std_LoadPoint(*arg1,arg2,*arg3,arg4);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Std_LoadPoint__SWIG_5(void * jarg1, char * jarg2, void * jarg3) {
  unsigned int jresult ;
  CStdXml *arg1 = 0 ;
  std::string arg2 ;
  CStdPoint< float > *arg3 = 0 ;
  bool result;
  
  arg1 = (CStdXml *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdXml & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (CStdPoint< float > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< float > & type is null", 0);
    return 0;
  } 
  result = (bool)StdUtils::Std_LoadPoint(*arg1,arg2,*arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Std_LoadPoint__SWIG_6(void * jarg1, char * jarg2, void * jarg3, unsigned int jarg4) {
  unsigned int jresult ;
  CStdXml *arg1 = 0 ;
  std::string arg2 ;
  CStdPoint< double > *arg3 = 0 ;
  bool arg4 ;
  bool result;
  
  arg1 = (CStdXml *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdXml & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (CStdPoint< double > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< double > & type is null", 0);
    return 0;
  } 
  arg4 = jarg4 ? true : false; 
  result = (bool)StdUtils::Std_LoadPoint(*arg1,arg2,*arg3,arg4);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Std_LoadPoint__SWIG_7(void * jarg1, char * jarg2, void * jarg3) {
  unsigned int jresult ;
  CStdXml *arg1 = 0 ;
  std::string arg2 ;
  CStdPoint< double > *arg3 = 0 ;
  bool result;
  
  arg1 = (CStdXml *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdXml & type is null", 0);
    return 0;
  } 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (CStdPoint< double > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< double > & type is null", 0);
    return 0;
  } 
  result = (bool)StdUtils::Std_LoadPoint(*arg1,arg2,*arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Std_LoadPoint__SWIG_8(void * jarg1, int jarg2, void * jarg3) {
  CStdXml *arg1 = 0 ;
  int arg2 ;
  CStdPoint< int > *arg3 = 0 ;
  
  arg1 = (CStdXml *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdXml & type is null", 0);
    return ;
  } 
  arg2 = (int)jarg2; 
  arg3 = (CStdPoint< int > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< int > & type is null", 0);
    return ;
  } 
  StdUtils::Std_LoadPoint(*arg1,arg2,*arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Std_LoadPoint__SWIG_9(void * jarg1, int jarg2, void * jarg3) {
  CStdXml *arg1 = 0 ;
  int arg2 ;
  CStdPoint< long > *arg3 = 0 ;
  
  arg1 = (CStdXml *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdXml & type is null", 0);
    return ;
  } 
  arg2 = (int)jarg2; 
  arg3 = (CStdPoint< long > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< long > & type is null", 0);
    return ;
  } 
  StdUtils::Std_LoadPoint(*arg1,arg2,*arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Std_LoadPoint__SWIG_10(void * jarg1, int jarg2, void * jarg3) {
  CStdXml *arg1 = 0 ;
  int arg2 ;
  CStdPoint< float > *arg3 = 0 ;
  
  arg1 = (CStdXml *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdXml & type is null", 0);
    return ;
  } 
  arg2 = (int)jarg2; 
  arg3 = (CStdPoint< float > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< float > & type is null", 0);
    return ;
  } 
  StdUtils::Std_LoadPoint(*arg1,arg2,*arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_Std_LoadPoint__SWIG_11(void * jarg1, int jarg2, void * jarg3) {
  CStdXml *arg1 = 0 ;
  int arg2 ;
  CStdPoint< double > *arg3 = 0 ;
  
  arg1 = (CStdXml *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdXml & type is null", 0);
    return ;
  } 
  arg2 = (int)jarg2; 
  arg3 = (CStdPoint< double > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< double > & type is null", 0);
    return ;
  } 
  StdUtils::Std_LoadPoint(*arg1,arg2,*arg3);
}


SWIGEXPORT double SWIGSTDCALL CSharp_Std_CalculateDistance__SWIG_0(void * jarg1, void * jarg2) {
  double jresult ;
  CStdPoint< int > *arg1 = 0 ;
  CStdPoint< int > *arg2 = 0 ;
  double result;
  
  arg1 = (CStdPoint< int > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< int > & type is null", 0);
    return 0;
  } 
  arg2 = (CStdPoint< int > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< int > & type is null", 0);
    return 0;
  } 
  result = (double)StdUtils::Std_CalculateDistance(*arg1,*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_Std_CalculateDistance__SWIG_1(void * jarg1, void * jarg2) {
  double jresult ;
  CStdPoint< long > *arg1 = 0 ;
  CStdPoint< long > *arg2 = 0 ;
  double result;
  
  arg1 = (CStdPoint< long > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< long > & type is null", 0);
    return 0;
  } 
  arg2 = (CStdPoint< long > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< long > & type is null", 0);
    return 0;
  } 
  result = (double)StdUtils::Std_CalculateDistance(*arg1,*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_Std_CalculateDistance__SWIG_2(void * jarg1, void * jarg2) {
  double jresult ;
  CStdPoint< float > *arg1 = 0 ;
  CStdPoint< float > *arg2 = 0 ;
  double result;
  
  arg1 = (CStdPoint< float > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< float > & type is null", 0);
    return 0;
  } 
  arg2 = (CStdPoint< float > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< float > & type is null", 0);
    return 0;
  } 
  result = (double)StdUtils::Std_CalculateDistance(*arg1,*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_Std_CalculateDistance__SWIG_3(void * jarg1, void * jarg2) {
  double jresult ;
  CStdPoint< double > *arg1 = 0 ;
  CStdPoint< double > *arg2 = 0 ;
  double result;
  
  arg1 = (CStdPoint< double > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< double > & type is null", 0);
    return 0;
  } 
  arg2 = (CStdPoint< double > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "CStdPoint< double > & type is null", 0);
    return 0;
  } 
  result = (double)StdUtils::Std_CalculateDistance(*arg1,*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_Std_CalculateDistance__SWIG_4(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
  double jresult ;
  float arg1 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  float arg6 ;
  double result;
  
  arg1 = (float)jarg1; 
  arg2 = (float)jarg2; 
  arg3 = (float)jarg3; 
  arg4 = (float)jarg4; 
  arg5 = (float)jarg5; 
  arg6 = (float)jarg6; 
  result = (double)StdUtils::Std_CalculateDistance(arg1,arg2,arg3,arg4,arg5,arg6);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_CMarkupSTL__SWIG_0() {
  void * jresult ;
  StdUtils::CMarkupSTL *result = 0 ;
  
  result = (StdUtils::CMarkupSTL *)new StdUtils::CMarkupSTL();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_CMarkupSTL__SWIG_1(char * jarg1) {
  void * jresult ;
  char *arg1 = (char *) 0 ;
  StdUtils::CMarkupSTL *result = 0 ;
  
  arg1 = (char *)jarg1; 
  result = (StdUtils::CMarkupSTL *)new StdUtils::CMarkupSTL((char const *)arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_CMarkupSTL__SWIG_2(void * jarg1) {
  void * jresult ;
  StdUtils::CMarkupSTL *arg1 = 0 ;
  StdUtils::CMarkupSTL *result = 0 ;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "StdUtils::CMarkupSTL const & type is null", 0);
    return 0;
  } 
  result = (StdUtils::CMarkupSTL *)new StdUtils::CMarkupSTL((StdUtils::CMarkupSTL const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_CMarkupSTL(void * jarg1) {
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  delete arg1;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_Load(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (bool)(arg1)->Load((char const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_SetDoc(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (bool)(arg1)->SetDoc((char const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_IsWellFormed(void * jarg1) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  result = (bool)(arg1)->IsWellFormed();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_FindElem__SWIG_0(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (bool)(arg1)->FindElem((char const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_FindElem__SWIG_1(void * jarg1) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  result = (bool)(arg1)->FindElem();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_FindChildElem__SWIG_0(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (bool)(arg1)->FindChildElem((char const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_FindChildElem__SWIG_1(void * jarg1) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  result = (bool)(arg1)->FindChildElem();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_IntoElem(void * jarg1) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  result = (bool)(arg1)->IntoElem();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_OutOfElem(void * jarg1) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  result = (bool)(arg1)->OutOfElem();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_CMarkupSTL_ResetChildPos(void * jarg1) {
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  (arg1)->ResetChildPos();
}


SWIGEXPORT void SWIGSTDCALL CSharp_CMarkupSTL_ResetMainPos(void * jarg1) {
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  (arg1)->ResetMainPos();
}


SWIGEXPORT void SWIGSTDCALL CSharp_CMarkupSTL_ResetPos(void * jarg1) {
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  (arg1)->ResetPos();
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CMarkupSTL_GetTagName(void * jarg1) {
  char * jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  std::string result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  result = ((StdUtils::CMarkupSTL const *)arg1)->GetTagName();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CMarkupSTL_GetChildTagName(void * jarg1) {
  char * jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  std::string result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  result = ((StdUtils::CMarkupSTL const *)arg1)->GetChildTagName();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CMarkupSTL_GetData(void * jarg1) {
  char * jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  std::string result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  result = ((StdUtils::CMarkupSTL const *)arg1)->GetData();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CMarkupSTL_GetChildData(void * jarg1) {
  char * jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  std::string result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  result = ((StdUtils::CMarkupSTL const *)arg1)->GetChildData();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CMarkupSTL_GetAttrib(void * jarg1, char * jarg2) {
  char * jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  std::string result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  result = ((StdUtils::CMarkupSTL const *)arg1)->GetAttrib((char const *)arg2);
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CMarkupSTL_GetChildAttrib(void * jarg1, char * jarg2) {
  char * jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  std::string result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  result = ((StdUtils::CMarkupSTL const *)arg1)->GetChildAttrib((char const *)arg2);
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CMarkupSTL_GetAttribName(void * jarg1, int jarg2) {
  char * jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  int arg2 ;
  std::string result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (int)jarg2; 
  result = ((StdUtils::CMarkupSTL const *)arg1)->GetAttribName(arg2);
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_SavePos__SWIG_0(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (bool)(arg1)->SavePos((char const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_SavePos__SWIG_1(void * jarg1) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  result = (bool)(arg1)->SavePos();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_RestorePos__SWIG_0(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (bool)(arg1)->RestorePos((char const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_RestorePos__SWIG_1(void * jarg1) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  result = (bool)(arg1)->RestorePos();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_GetOffsets(void * jarg1, int * jarg2, int * jarg3) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (int *)jarg2; 
  arg3 = (int *)jarg3; 
  result = (bool)((StdUtils::CMarkupSTL const *)arg1)->GetOffsets(*arg2,*arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CMarkupSTL_GetError(void * jarg1) {
  char * jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  std::string result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  result = ((StdUtils::CMarkupSTL const *)arg1)->GetError();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_Save(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (bool)(arg1)->Save((char const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CMarkupSTL_GetDoc(void * jarg1) {
  char * jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  std::string result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  result = ((StdUtils::CMarkupSTL const *)arg1)->GetDoc();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_AddElem__SWIG_0(void * jarg1, char * jarg2, char * jarg3) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (char *)jarg3; 
  result = (bool)(arg1)->AddElem((char const *)arg2,(char const *)arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_AddElem__SWIG_1(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (bool)(arg1)->AddElem((char const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_InsertElem__SWIG_0(void * jarg1, char * jarg2, char * jarg3) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (char *)jarg3; 
  result = (bool)(arg1)->InsertElem((char const *)arg2,(char const *)arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_InsertElem__SWIG_1(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (bool)(arg1)->InsertElem((char const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_AddChildElem__SWIG_0(void * jarg1, char * jarg2, char * jarg3) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (char *)jarg3; 
  result = (bool)(arg1)->AddChildElem((char const *)arg2,(char const *)arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_AddChildElem__SWIG_1(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (bool)(arg1)->AddChildElem((char const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_InsertChildElem__SWIG_0(void * jarg1, char * jarg2, char * jarg3) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (char *)jarg3; 
  result = (bool)(arg1)->InsertChildElem((char const *)arg2,(char const *)arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_InsertChildElem__SWIG_1(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (bool)(arg1)->InsertChildElem((char const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_AddAttrib__SWIG_0(void * jarg1, char * jarg2, char * jarg3) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (char *)jarg3; 
  result = (bool)(arg1)->AddAttrib((char const *)arg2,(char const *)arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_AddChildAttrib__SWIG_0(void * jarg1, char * jarg2, char * jarg3) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (char *)jarg3; 
  result = (bool)(arg1)->AddChildAttrib((char const *)arg2,(char const *)arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_AddAttrib__SWIG_1(void * jarg1, char * jarg2, int jarg3) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (int)jarg3; 
  result = (bool)(arg1)->AddAttrib((char const *)arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_AddChildAttrib__SWIG_1(void * jarg1, char * jarg2, int jarg3) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (int)jarg3; 
  result = (bool)(arg1)->AddChildAttrib((char const *)arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_AddChildSubDoc(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (bool)(arg1)->AddChildSubDoc((char const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_InsertChildSubDoc(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (bool)(arg1)->InsertChildSubDoc((char const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CMarkupSTL_GetChildSubDoc(void * jarg1) {
  char * jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  std::string result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  result = ((StdUtils::CMarkupSTL const *)arg1)->GetChildSubDoc();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_RemoveElem(void * jarg1) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  result = (bool)(arg1)->RemoveElem();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_RemoveChildElem(void * jarg1) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  result = (bool)(arg1)->RemoveChildElem();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_SetAttrib__SWIG_0(void * jarg1, char * jarg2, char * jarg3) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (char *)jarg3; 
  result = (bool)(arg1)->SetAttrib((char const *)arg2,(char const *)arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_SetChildAttrib__SWIG_0(void * jarg1, char * jarg2, char * jarg3) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (char *)jarg3; 
  result = (bool)(arg1)->SetChildAttrib((char const *)arg2,(char const *)arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_SetAttrib__SWIG_1(void * jarg1, char * jarg2, int jarg3) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (int)jarg3; 
  result = (bool)(arg1)->SetAttrib((char const *)arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_SetChildAttrib__SWIG_1(void * jarg1, char * jarg2, int jarg3) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (int)jarg3; 
  result = (bool)(arg1)->SetChildAttrib((char const *)arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_SetData__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (int)jarg3; 
  result = (bool)(arg1)->SetData((char const *)arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_SetData__SWIG_1(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (bool)(arg1)->SetData((char const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_SetChildData__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (int)jarg3; 
  result = (bool)(arg1)->SetChildData((char const *)arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CMarkupSTL_SetChildData__SWIG_1(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  StdUtils::CMarkupSTL *arg1 = (StdUtils::CMarkupSTL *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CMarkupSTL *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (bool)(arg1)->SetChildData((char const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_CStdXml() {
  void * jresult ;
  StdUtils::CStdXml *result = 0 ;
  
  result = (StdUtils::CStdXml *)new StdUtils::CStdXml();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_CStdXml(void * jarg1) {
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  delete arg1;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CStdXml_Serialize(void * jarg1) {
  char * jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  result = (arg1)->Serialize();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdXml_Deserialize(void * jarg1, void * jarg2) {
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  arg2 = (std::string *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::string & type is null", 0);
    return ;
  } 
  (arg1)->Deserialize(*arg2);
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CStdXml_IntoElem(void * jarg1) {
  unsigned int jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  result = (bool)(arg1)->IntoElem();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CStdXml_OutOfElem(void * jarg1) {
  unsigned int jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  result = (bool)(arg1)->OutOfElem();
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CStdXml_FullTagPath__SWIG_0(void * jarg1, unsigned int jarg2) {
  char * jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  bool arg2 ;
  std::string result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  arg2 = jarg2 ? true : false; 
  result = (arg1)->FullTagPath(arg2);
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CStdXml_FullTagPath__SWIG_1(void * jarg1) {
  char * jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  result = (arg1)->FullTagPath();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_CStdXml_NumberOfChildren(void * jarg1) {
  int jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  int result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  result = (int)(arg1)->NumberOfChildren();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CStdXml_FindElement__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
  unsigned int jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  bool result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  result = (bool)(arg1)->FindElement(arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CStdXml_FindElement__SWIG_1(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  result = (bool)(arg1)->FindElement(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CStdXml_FindChildByIndex__SWIG_0(void * jarg1, int jarg2, unsigned int jarg3) {
  unsigned int jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  int arg2 ;
  bool arg3 ;
  bool result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? true : false; 
  result = (bool)(arg1)->FindChildByIndex(arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CStdXml_FindChildByIndex__SWIG_1(void * jarg1, int jarg2) {
  unsigned int jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  int arg2 ;
  bool result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  arg2 = (int)jarg2; 
  result = (bool)(arg1)->FindChildByIndex(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CStdXml_FindChildElement__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
  unsigned int jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  bool result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  result = (bool)(arg1)->FindChildElement(arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CStdXml_FindChildElement__SWIG_1(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  result = (bool)(arg1)->FindChildElement(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CStdXml_IntoChildElement__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
  unsigned int jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  bool result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  result = (bool)(arg1)->IntoChildElement(arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CStdXml_IntoChildElement__SWIG_1(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  result = (bool)(arg1)->IntoChildElement(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CStdXml_GetChildString__SWIG_0(void * jarg1, char * jarg2) {
  char * jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  std::string result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  result = (arg1)->GetChildString(arg2);
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CStdXml_GetChildString__SWIG_1(void * jarg1, char * jarg2, char * jarg3) {
  char * jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::string result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg3)->assign(jarg3); 
  result = (arg1)->GetChildString(arg2,arg3);
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CStdXml_GetChildString__SWIG_2(void * jarg1) {
  char * jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  result = (arg1)->GetChildString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT long SWIGSTDCALL CSharp_CStdXml_GetChildLong__SWIG_0(void * jarg1, char * jarg2) {
  long jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  long result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  result = (long)(arg1)->GetChildLong(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT long SWIGSTDCALL CSharp_CStdXml_GetChildLong__SWIG_1(void * jarg1, char * jarg2, long jarg3) {
  long jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  long arg3 ;
  long result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (long)jarg3; 
  result = (long)(arg1)->GetChildLong(arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT long SWIGSTDCALL CSharp_CStdXml_GetChildLong__SWIG_2(void * jarg1) {
  long jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  long result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  result = (long)(arg1)->GetChildLong();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_CStdXml_GetChildInt__SWIG_0(void * jarg1, char * jarg2) {
  int jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  int result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  result = (int)(arg1)->GetChildInt(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_CStdXml_GetChildInt__SWIG_1(void * jarg1, char * jarg2, int jarg3) {
  int jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  int arg3 ;
  int result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (int)jarg3; 
  result = (int)(arg1)->GetChildInt(arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_CStdXml_GetChildInt__SWIG_2(void * jarg1) {
  int jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  int result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  result = (int)(arg1)->GetChildInt();
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_CStdXml_GetChildDouble__SWIG_0(void * jarg1, char * jarg2) {
  double jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  double result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  result = (double)(arg1)->GetChildDouble(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_CStdXml_GetChildDouble__SWIG_1(void * jarg1, char * jarg2, double jarg3) {
  double jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  double arg3 ;
  double result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (double)jarg3; 
  result = (double)(arg1)->GetChildDouble(arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_CStdXml_GetChildDouble__SWIG_2(void * jarg1) {
  double jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  double result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  result = (double)(arg1)->GetChildDouble();
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_CStdXml_GetChildFloat__SWIG_0(void * jarg1, char * jarg2) {
  float jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  float result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  result = (float)(arg1)->GetChildFloat(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_CStdXml_GetChildFloat__SWIG_1(void * jarg1, char * jarg2, float jarg3) {
  float jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  float arg3 ;
  float result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (float)jarg3; 
  result = (float)(arg1)->GetChildFloat(arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_CStdXml_GetChildFloat__SWIG_2(void * jarg1) {
  float jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  float result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  result = (float)(arg1)->GetChildFloat();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CStdXml_GetChildBool__SWIG_0(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  result = (bool)(arg1)->GetChildBool(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CStdXml_GetChildBool__SWIG_1(void * jarg1, char * jarg2, unsigned int jarg3) {
  unsigned int jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  bool result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  result = (bool)(arg1)->GetChildBool(arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CStdXml_GetChildBool__SWIG_2(void * jarg1) {
  unsigned int jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  bool result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  result = (bool)(arg1)->GetChildBool();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdXml_AddElement__SWIG_0(void * jarg1, char * jarg2, char * jarg3) {
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg3)->assign(jarg3); 
  (arg1)->AddElement(arg2,arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdXml_AddElement__SWIG_1(void * jarg1, char * jarg2) {
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  (arg1)->AddElement(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdXml_AddChildElement__SWIG_0(void * jarg1, char * jarg2) {
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  (arg1)->AddChildElement(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdXml_AddChildElement__SWIG_1(void * jarg1, char * jarg2, char * jarg3) {
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg3)->assign(jarg3); 
  (arg1)->AddChildElement(arg2,arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdXml_AddChildElement__SWIG_2(void * jarg1, char * jarg2, char jarg3) {
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  char arg3 ;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (char)jarg3; 
  (arg1)->AddChildElement(arg2,arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdXml_AddChildElement__SWIG_3(void * jarg1, char * jarg2, unsigned char jarg3) {
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  unsigned char arg3 ;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (unsigned char)jarg3; 
  (arg1)->AddChildElement(arg2,arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdXml_AddChildElement__SWIG_4(void * jarg1, char * jarg2, long jarg3) {
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  long arg3 ;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (long)jarg3; 
  (arg1)->AddChildElement(arg2,arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdXml_AddChildElement__SWIG_6(void * jarg1, char * jarg2, double jarg3) {
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  double arg3 ;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (double)jarg3; 
  (arg1)->AddChildElement(arg2,arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdXml_AddChildElement__SWIG_7(void * jarg1, char * jarg2, float jarg3) {
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  float arg3 ;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (float)jarg3; 
  (arg1)->AddChildElement(arg2,arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdXml_AddChildElement__SWIG_8(void * jarg1, char * jarg2, unsigned int jarg3) {
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  (arg1)->AddChildElement(arg2,arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdXml_AddChildCData(void * jarg1, char * jarg2, char * jarg3) {
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg3)->assign(jarg3); 
  (arg1)->AddChildCData(arg2,arg3);
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CStdXml_GetAttribString__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4, char * jarg5) {
  char * jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  bool arg4 ;
  std::string arg5 ;
  std::string result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  if (!jarg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg5)->assign(jarg5); 
  result = (arg1)->GetAttribString(arg2,arg3,arg4,arg5);
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CStdXml_GetAttribString__SWIG_1(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4) {
  char * jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  bool arg4 ;
  std::string result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  result = (arg1)->GetAttribString(arg2,arg3,arg4);
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CStdXml_GetAttribString__SWIG_2(void * jarg1, char * jarg2, unsigned int jarg3) {
  char * jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  std::string result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  result = (arg1)->GetAttribString(arg2,arg3);
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CStdXml_GetAttribString__SWIG_3(void * jarg1, char * jarg2) {
  char * jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  std::string result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  result = (arg1)->GetAttribString(arg2);
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT long SWIGSTDCALL CSharp_CStdXml_GetAttribLong__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3, long jarg4) {
  long jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  long arg4 ;
  long result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  arg4 = (long)jarg4; 
  result = (long)(arg1)->GetAttribLong(arg2,arg3,arg4);
  jresult = result; 
  return jresult;
}


SWIGEXPORT long SWIGSTDCALL CSharp_CStdXml_GetAttribLong__SWIG_1(void * jarg1, char * jarg2, unsigned int jarg3) {
  long jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  long result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  result = (long)(arg1)->GetAttribLong(arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT long SWIGSTDCALL CSharp_CStdXml_GetAttribLong__SWIG_2(void * jarg1, char * jarg2) {
  long jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  long result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  result = (long)(arg1)->GetAttribLong(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_CStdXml_GetAttribInt__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3, int jarg4) {
  int jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  int arg4 ;
  int result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  arg4 = (int)jarg4; 
  result = (int)(arg1)->GetAttribInt(arg2,arg3,arg4);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_CStdXml_GetAttribInt__SWIG_1(void * jarg1, char * jarg2, unsigned int jarg3) {
  int jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  int result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  result = (int)(arg1)->GetAttribInt(arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_CStdXml_GetAttribInt__SWIG_2(void * jarg1, char * jarg2) {
  int jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  int result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  result = (int)(arg1)->GetAttribInt(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_CStdXml_GetAttribDouble__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3, double jarg4) {
  double jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  double arg4 ;
  double result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  arg4 = (double)jarg4; 
  result = (double)(arg1)->GetAttribDouble(arg2,arg3,arg4);
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_CStdXml_GetAttribDouble__SWIG_1(void * jarg1, char * jarg2, unsigned int jarg3) {
  double jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  double result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  result = (double)(arg1)->GetAttribDouble(arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_CStdXml_GetAttribDouble__SWIG_2(void * jarg1, char * jarg2) {
  double jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  double result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  result = (double)(arg1)->GetAttribDouble(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_CStdXml_GetAttribFloat__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3, float jarg4) {
  float jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  float arg4 ;
  float result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  arg4 = (float)jarg4; 
  result = (float)(arg1)->GetAttribFloat(arg2,arg3,arg4);
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_CStdXml_GetAttribFloat__SWIG_1(void * jarg1, char * jarg2, unsigned int jarg3) {
  float jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  float result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  result = (float)(arg1)->GetAttribFloat(arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_CStdXml_GetAttribFloat__SWIG_2(void * jarg1, char * jarg2) {
  float jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  float result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  result = (float)(arg1)->GetAttribFloat(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CStdXml_GetAttribBool__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4) {
  unsigned int jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  result = (bool)(arg1)->GetAttribBool(arg2,arg3,arg4);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CStdXml_GetAttribBool__SWIG_1(void * jarg1, char * jarg2, unsigned int jarg3) {
  unsigned int jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  bool result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  result = (bool)(arg1)->GetAttribBool(arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CStdXml_GetAttribBool__SWIG_2(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  result = (bool)(arg1)->GetAttribBool(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdXml_SetAttrib__SWIG_0(void * jarg1, char * jarg2, char * jarg3) {
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg3)->assign(jarg3); 
  (arg1)->SetAttrib(arg2,arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdXml_SetAttrib__SWIG_1(void * jarg1, char * jarg2, char jarg3) {
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  char arg3 ;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (char)jarg3; 
  (arg1)->SetAttrib(arg2,arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdXml_SetAttrib__SWIG_2(void * jarg1, char * jarg2, unsigned char jarg3) {
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  unsigned char arg3 ;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (unsigned char)jarg3; 
  (arg1)->SetAttrib(arg2,arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdXml_SetAttrib__SWIG_3(void * jarg1, char * jarg2, long jarg3) {
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  long arg3 ;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (long)jarg3; 
  (arg1)->SetAttrib(arg2,arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdXml_SetAttrib__SWIG_5(void * jarg1, char * jarg2, double jarg3) {
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  double arg3 ;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (double)jarg3; 
  (arg1)->SetAttrib(arg2,arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdXml_SetAttrib__SWIG_6(void * jarg1, char * jarg2, float jarg3) {
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  float arg3 ;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (float)jarg3; 
  (arg1)->SetAttrib(arg2,arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdXml_SetAttrib__SWIG_7(void * jarg1, char * jarg2, unsigned int jarg3) {
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  (arg1)->SetAttrib(arg2,arg3);
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CStdXml_GetChildAttribString__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4, char * jarg5) {
  char * jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  bool arg4 ;
  std::string arg5 ;
  std::string result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  if (!jarg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg5)->assign(jarg5); 
  result = (arg1)->GetChildAttribString(arg2,arg3,arg4,arg5);
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CStdXml_GetChildAttribString__SWIG_1(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4) {
  char * jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  bool arg4 ;
  std::string result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  result = (arg1)->GetChildAttribString(arg2,arg3,arg4);
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CStdXml_GetChildAttribString__SWIG_2(void * jarg1, char * jarg2, unsigned int jarg3) {
  char * jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  std::string result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  result = (arg1)->GetChildAttribString(arg2,arg3);
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CStdXml_GetChildAttribString__SWIG_3(void * jarg1, char * jarg2) {
  char * jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  std::string result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  result = (arg1)->GetChildAttribString(arg2);
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT long SWIGSTDCALL CSharp_CStdXml_GetChildAttribLong__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3, long jarg4) {
  long jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  long arg4 ;
  long result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  arg4 = (long)jarg4; 
  result = (long)(arg1)->GetChildAttribLong(arg2,arg3,arg4);
  jresult = result; 
  return jresult;
}


SWIGEXPORT long SWIGSTDCALL CSharp_CStdXml_GetChildAttribLong__SWIG_1(void * jarg1, char * jarg2, unsigned int jarg3) {
  long jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  long result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  result = (long)(arg1)->GetChildAttribLong(arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT long SWIGSTDCALL CSharp_CStdXml_GetChildAttribLong__SWIG_2(void * jarg1, char * jarg2) {
  long jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  long result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  result = (long)(arg1)->GetChildAttribLong(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_CStdXml_GetChildAttribInt__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3, int jarg4) {
  int jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  int arg4 ;
  int result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  arg4 = (int)jarg4; 
  result = (int)(arg1)->GetChildAttribInt(arg2,arg3,arg4);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_CStdXml_GetChildAttribInt__SWIG_1(void * jarg1, char * jarg2, unsigned int jarg3) {
  int jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  int result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  result = (int)(arg1)->GetChildAttribInt(arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_CStdXml_GetChildAttribInt__SWIG_2(void * jarg1, char * jarg2) {
  int jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  int result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  result = (int)(arg1)->GetChildAttribInt(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_CStdXml_GetChildAttribDouble__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3, double jarg4) {
  double jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  double arg4 ;
  double result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  arg4 = (double)jarg4; 
  result = (double)(arg1)->GetChildAttribDouble(arg2,arg3,arg4);
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_CStdXml_GetChildAttribDouble__SWIG_1(void * jarg1, char * jarg2, unsigned int jarg3) {
  double jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  double result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  result = (double)(arg1)->GetChildAttribDouble(arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_CStdXml_GetChildAttribDouble__SWIG_2(void * jarg1, char * jarg2) {
  double jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  double result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  result = (double)(arg1)->GetChildAttribDouble(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_CStdXml_GetChildAttribFloat__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3, float jarg4) {
  float jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  float arg4 ;
  float result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  arg4 = (float)jarg4; 
  result = (float)(arg1)->GetChildAttribFloat(arg2,arg3,arg4);
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_CStdXml_GetChildAttribFloat__SWIG_1(void * jarg1, char * jarg2, unsigned int jarg3) {
  float jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  float result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  result = (float)(arg1)->GetChildAttribFloat(arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_CStdXml_GetChildAttribFloat__SWIG_2(void * jarg1, char * jarg2) {
  float jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  float result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  result = (float)(arg1)->GetChildAttribFloat(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CStdXml_GetChildAttribBool__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4) {
  unsigned int jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  result = (bool)(arg1)->GetChildAttribBool(arg2,arg3,arg4);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CStdXml_GetChildAttribBool__SWIG_1(void * jarg1, char * jarg2, unsigned int jarg3) {
  unsigned int jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  bool result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  result = (bool)(arg1)->GetChildAttribBool(arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_CStdXml_GetChildAttribBool__SWIG_2(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  (&arg2)->assign(jarg2); 
  result = (bool)(arg1)->GetChildAttribBool(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdXml_SetChildAttrib__SWIG_0(void * jarg1, char * jarg2, char * jarg3) {
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg3)->assign(jarg3); 
  (arg1)->SetChildAttrib(arg2,arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdXml_SetChildAttrib__SWIG_1(void * jarg1, char * jarg2, char jarg3) {
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  char arg3 ;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (char)jarg3; 
  (arg1)->SetChildAttrib(arg2,arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdXml_SetChildAttrib__SWIG_2(void * jarg1, char * jarg2, unsigned char jarg3) {
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  unsigned char arg3 ;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (unsigned char)jarg3; 
  (arg1)->SetChildAttrib(arg2,arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdXml_SetChildAttrib__SWIG_3(void * jarg1, char * jarg2, long jarg3) {
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  long arg3 ;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (long)jarg3; 
  (arg1)->SetChildAttrib(arg2,arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdXml_SetChildAttrib__SWIG_5(void * jarg1, char * jarg2, double jarg3) {
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  double arg3 ;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (double)jarg3; 
  (arg1)->SetChildAttrib(arg2,arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdXml_SetChildAttrib__SWIG_6(void * jarg1, char * jarg2, float jarg3) {
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  float arg3 ;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  arg3 = (float)jarg3; 
  (arg1)->SetChildAttrib(arg2,arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdXml_SetChildAttrib__SWIG_7(void * jarg1, char * jarg2, unsigned int jarg3) {
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  arg3 = jarg3 ? true : false; 
  (arg1)->SetChildAttrib(arg2,arg3);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdXml_AddChildDoc(void * jarg1, void * jarg2) {
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  arg2 = (std::string *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::string & type is null", 0);
    return ;
  } 
  (arg1)->AddChildDoc(*arg2);
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CStdXml_GetChildDoc(void * jarg1) {
  char * jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  result = (arg1)->GetChildDoc();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CStdXml_GetParentTagName(void * jarg1) {
  char * jresult ;
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string result;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  result = (arg1)->GetParentTagName();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdXml_Load(void * jarg1, char * jarg2) {
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  (arg1)->Load(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_CStdXml_Save(void * jarg1, char * jarg2) {
  StdUtils::CStdXml *arg1 = (StdUtils::CStdXml *) 0 ;
  std::string arg2 ;
  
  arg1 = (StdUtils::CStdXml *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  (&arg2)->assign(jarg2); 
  (arg1)->Save(arg2);
}


SWIGEXPORT StdUtils::CMarkupSTL * SWIGSTDCALL CSharp_CStdXml_SWIGUpcast(StdUtils::CStdXml *jarg1) {
    return (StdUtils::CMarkupSTL *)jarg1;
}

#ifdef __cplusplus
}
#endif