/* -----------------------------------------------------------------------------
 * objc.swg
 *
 * Objective-C module typemaps: 
 * Note that the intermediate layer (ObjectiveC++) is essentially a C layer with the 
 * C++ specific code (such as references) converted to the C code. Since ObjectiveC
 * layer can handle C as is, this makes sense - at least until we decide on something 
 * more appropriate.

 * ----------------------------------------------------------------------------- */

/* 
 * IMTYPE TYPEMAPS: Represents the ObjectiveC++ type corresponding to each C++ type. 
 */
 
// Primary types: ObjectiveC++ understands C primary types.
%typemap(imtype) bool               "bool"
%typemap(imtype) char               "char"
%typemap(imtype) signed char        "signed char"
%typemap(imtype) unsigned char      "unsigned char"
%typemap(imtype) short              "short"
%typemap(imtype) unsigned short     "unsigned short"
%typemap(imtype) int                "int"
%typemap(imtype) unsigned int       "unsigned int"
%typemap(imtype) long               "long"
%typemap(imtype) unsigned long      "unsigned long"
%typemap(imtype) long long          "long long"
%typemap(imtype) unsigned long long "unsigned long long"
%typemap(imtype) float              "float"
%typemap(imtype) double             "double"
%typemap(imtype) void               "void"

// References to primitive types are treated as pointers in the wrapper(ObjectiveC++) layer.
%typemap(imtype) const bool &,              bool &                  "bool *"
%typemap(imtype) const char &,              char &                  "char *"
%typemap(imtype) const signed char &, 		signed char &           "signed char *"
%typemap(imtype) const unsigned char &, 	unsigned char &         "unsigned char *"
%typemap(imtype) const short &,				short &                 "short *"
%typemap(imtype) const unsigned short &,	unsigned short &        "unsigned short *"
%typemap(imtype) const int &,		    	int &                   "int *"
%typemap(imtype) const unsigned int &,		unsigned int &          "unsigned int *"
%typemap(imtype) const long &,				long &                  "long *"
%typemap(imtype) const unsigned long &, 	unsigned long &         "unsigned long  *"
%typemap(imtype) const long long &, 		long long &             "long long *"
%typemap(imtype) const unsigned long long &,unsigned long long &    "unsigned long long  *"
%typemap(imtype) const float &, 			float &                 "float *"
%typemap(imtype) const double &,  			double &                "double *"

//C strings:
%typemap(imtype) char *, char[ANY], char[]              "NSString *"
%typemap(imtype) char *&                                "NSString *"

// Objects will always be treated as pointers in ObjectiveC++
%typemap(imtype) SWIGTYPE                               "void*" 

// C/C++ prinitve pointers are treated as is in ObjectiveC++
// References to primitive types are treated as pointers in the wrapper(ObjectiveC++) layer.
%typemap(imtype) const bool *,              bool *                  "bool *"
%typemap(imtype) const signed char *, 		signed char *           "signed char *"
%typemap(imtype) const unsigned char *, 	unsigned char *         "unsigned char *"
%typemap(imtype) const short *,				short *                 "short *"
%typemap(imtype) const unsigned short *,	unsigned short *        "unsigned short *"
%typemap(imtype) const int *,		    	int *                   "int *"
%typemap(imtype) const unsigned int *,		unsigned int *          "unsigned int *"
%typemap(imtype) const long *,				long *                  "long *"
%typemap(imtype) const unsigned long *, 	unsigned long *         "unsigned long  *"
%typemap(imtype) const long long *, 		long long *             "long long *"
%typemap(imtype) const unsigned long long *,unsigned long long *    "unsigned long long  *"
%typemap(imtype) const float *, 			float *                 "float *"
%typemap(imtype) const double *,  			double *                "double *"

// C/C++ object Pointers, are treated as void* in ObjectiveC++
%typemap(imtype) SWIGTYPE *                             "void*"

// Arrays for non-primitive types
%typemap(imtype) SWIGTYPE []                            "void*"

// Pointer to a class member will be void*
%typemap(imtype) SWIGTYPE (CLASS::*)                    "void*"  

// References to non-primitive types
%typemap(imtype) SWIGTYPE &                             "void*"
%typemap(imtype) SWIGTYPE *const&                       "void*"

// Function pointers
%typemap(imtype) SWIGTYPE ((*)(ANY))                    "void*"


/* 
 * IN TYPEMAPS: Used for "in" arguments type conversions: ObjectiveC++ to C++.
 */
%typemap(in) bool,
             char, 
             signed char, 
             unsigned char, 
             short, 
             unsigned short, 
             int, 
             unsigned int, 
             long, 
             unsigned long, 
             long long, 
             unsigned long long,
             float, 
             double
%{ $1 = ($1_ltype)$input; %}

// No "in" for void
%typemap(in) void ""

// References: are treated as pointers in the wrapper layer (ObjectiveC++)
%typemap(in) const bool &,              bool &,
             const char &,  			char &,
	     	 const signed char &, 		signed char &,
	         const unsigned char &, 	unsigned char &,
		     const short &,				short &,
		     const unsigned short &,	unsigned short &,
		     const int &,		    	int &,
		     const unsigned int &,		unsigned int &,
			 const long &,				long &,
	     	 const unsigned long &, 	unsigned long &,
	     	 const long long &, 		long long &,
	     	 const unsigned long long &,unsigned long long &,
	      	 const float &, 			float &,
	      	 const double &,  			double &
%{ $1 = ($1_ltype)$input; %}

%typemap(in) const bool *,              bool *,                  
 	const signed char *, 		signed char *,           
 	const unsigned char *, 	        unsigned char *,         
 	const short *,				short *,                 
 	const unsigned short *,	        unsigned short *,        
 	const int *,		    	int *,                   
 	const unsigned int *,		unsigned int *,          
 	const long *,				long *,                 
 	const unsigned long *, 	        unsigned long *,         
 	const long long *, 		long long *,             
 	const unsigned long long *,     unsigned long long *,    
 	const float *, 			float *,               
 	const double *,  	        double *        
%{ $1 = ($1_ltype)$input;%}

//C strings:
%typemap(in) char *, char[ANY], char[]  {
 $1 = 0;
  if ($input) { // TODO: Find a better way to do this!
		int length = [$input length];
		int bufferSize = sizeof(char) * (length + 1);
		char *buffer = (char*)malloc(bufferSize);
		memset(buffer, 0, bufferSize);
		int i = 0;
		for (; i < length; ++i)
			buffer[i] = [$input characterAtIndex: i];
			$1 = buffer;
	}
}

%typemap(in) char *& ($*1_ltype temp = 0) {
 $1 = 0;
  if ($input) { // TODO: Find a better way to do this!
		int length = [$input length];
		int bufferSize = sizeof(char) * (length + 1);
		char *buffer = (char*)malloc(bufferSize);
		memset(buffer, 0, bufferSize);
		int i = 0;
		for (; i < length; ++i)
			buffer[i] = [$input characterAtIndex: i];
    temp = ($*1_ltype)buffer;
    if (!temp) return NULL;
  }
  $1 = &temp;
}

// Objects passed by value: convert from a pointer to the C++ value object.
%typemap(in) SWIGTYPE ($&1_type argp)	
%{ 
  argp = ($&1_ltype)$input;
  $1 = *argp; 
%}

// C/C++ Pointers, primary and object, are treated as pointers in ObjectiveC++
%typemap(in) SWIGTYPE *
%{ $1 = ($1_ltype)$input; %}
   
// Object References
%typemap(in) SWIGTYPE &
%{ $1 = ($1_ltype)$input; %}

%typemap(in) SWIGTYPE *const& ($*1_ltype temp = 0)
%{ temp = ($*1_ltype)$input;
   $1 = ($1_ltype)&temp; %}
   
// Array conversion typemap
%typemap(in) SWIGTYPE [] %{ $1 = ($1_ltype)$input; %}

// Pointer to a class member will be passed as void*, convert appropriately
%typemap(in) SWIGTYPE (CLASS::*)
%{ $1 = *($&1_ltype)$input; %}

// Function pointers
%typemap(in) SWIGTYPE ((*)(ANY))
%{ $1 = ($1_ltype)$input; %}


/*
 * OUT TYPEMAPS: Used for return-type type conversions: C++ to ObjectiveC++
 */
//Primary types
%typemap(out) bool,
            char,
            signed char,
            unsigned char,
            short,
            unsigned short,
            int,
            unsigned int,
            long,
            unsigned long,
            long long,
            unsigned long long,
            float,
            double
%{ $result = $1; %}

//%typemap(out) bool
//%{ $result = $1? YES:NO; %}

%typemap(out) void ""

// References as exported as pointers (by default)
%typemap(out)const bool &,              bool &,
             const char &,  			char &,
	     	 const signed char &, 		signed char &,
	         const unsigned char &, 	unsigned char &,
		     const short &,				short &,
		     const unsigned short &,	unsigned short &,
		     const int &,		    	int &,
		     const unsigned int &,		unsigned int &,
			 const long &,				long &,
	     	 const unsigned long &, 	unsigned long &,
	     	 const long long &, 		long long &,
	     	 const unsigned long long &,unsigned long long &,
	      	 const float &, 			float &,
	      	 const double &,  			double &
%{ $result = $1; %}


%typemap(out)const bool *,              bool *,
             const char *,  			char *,
	     	 const signed char *, 		signed char *,
	         const unsigned char *, 	unsigned char *,
		     const short *,				short *,
		     const unsigned short *,	unsigned short *,
		     const int *,		    	int *,
		     const unsigned int *,		unsigned int *,
			 const long *,				long &,
	     	 const unsigned long *, 	unsigned long &,
	     	 const long long *, 		long long *,
	     	 const unsigned long long *,unsigned long long *,
	      	 const float *, 			float *,
	      	 const double *,  			double *
%{ $result = $1; %}

// C strings: 
%typemap(out)const char *,char * %{ if ($1) $result = [NSString stringWithUTF8String: $1]; %}
%typemap(out) char *& %{ if (*$1) $result = [NSString stringWithUTF8String: *$1]; %}
%typemap(out) char[ANY], char[] %{ if ($1) $result = [NSString stringWithUTF8String: $1]; %}

// Objects returned by value: convert to a pointer.
%typemap(out) SWIGTYPE ($&1_type temp)
#ifdef __cplusplus
%{
  temp = new $1_ltype((const $1_ltype &)$1); 
  $result = temp;
%}
#else
{
  $&1_ltype $1ptr = ($&1_ltype) malloc(sizeof($1_ltype));
  memmove($1ptr, &$1, sizeof($1_type));
  temp = $1ptr;
  $result = temp;
}
#endif

// Pointer objects are returned as void* in the ObjectiveC++ layer
%typemap(out) SWIGTYPE *, SWIGTYPE & 
%{ $result = (void*)$1; %}

%typemap(out) SWIGTYPE [] %{ $result = $1; %}

// Pointer to a class member will be returned as void*
%typemap(out) SWIGTYPE (CLASS::*) 
%{ $result = (void*)$1; %}

%typemap(out) SWIGTYPE *const&
%{ $result = (void *)*$1; %}

// Function pointers
%typemap(out) SWIGTYPE ((*)(ANY))
%{ $result = (void*)$1; %}

/* 
 * OBJCTYPE TYPEMAPS: Represents the ObjectiveC(proxy) type corresponding to each ObjectiveC++ type in the intermediate(wrapper) layer. 
 */
// Primary types
%typemap(objctype)  bool               "BOOL"
%typemap(objctype)  char               "char"
%typemap(objctype)  signed char        "signed char"
%typemap(objctype)  unsigned char      "unsigned char"
%typemap(objctype)  short              "short"
%typemap(objctype)  unsigned short     "unsigned short"
%typemap(objctype)  int                "int"
%typemap(objctype)  unsigned int       "unsigned int"
%typemap(objctype)  long               "long"
%typemap(objctype)  unsigned long      "unsigned long"
%typemap(objctype)  long long          "long long"
%typemap(objctype)  unsigned long long "unsigned long long"
%typemap(objctype)  float              "float"
%typemap(objctype)  double             "double"
%typemap(objctype)  void               "void"

// References will always be treated as pointers in the proxy layer (ObjectiveC)
%typemap(objctype) const bool &,              bool &                  "bool *"
%typemap(objctype) const char &,              char &                  "char *"
%typemap(objctype) const signed char &, 		signed char &           "signed char *"
%typemap(objctype) const unsigned char &, 	unsigned char &         "unsigned char *"
%typemap(objctype) const short &,				short &                 "short *"
%typemap(objctype) const unsigned short &,	unsigned short &        "unsigned short *"
%typemap(objctype) const int &,		    	int &                   "int *"
%typemap(objctype) const unsigned int &,		unsigned int &          "unsigned int *"
%typemap(objctype) const long &,				long &                  "long *"
%typemap(objctype) const unsigned long &, 	unsigned long &         "unsigned long  *"
%typemap(objctype) const long long &, 		long long &             "long long *"
%typemap(objctype) const unsigned long long &,unsigned long long &    "unsigned long long  *"
%typemap(objctype) const float &, 			float &                 "float *"
%typemap(objctype) const double &,  			double &                "double *"

//C strings:
%typemap(objctype) char *, char *&, char[ANY], char[]    "NSString *"

// Objects will always be treated as pointers in ObjectiveC
%typemap(objctype) SWIGTYPE                             "$objcclassname*"

// C/C++ Pointers to primitive types are treated as is
// C/C++ prinitve pointers are treated as is in ObjectiveC++
// References to primitive types are treated as pointers in the wrapper(ObjectiveC++) layer.
%typemap(objctype) const bool *,              bool *                  "bool *"
%typemap(objctype) const signed char *, 		signed char *           "signed char *"
%typemap(objctype) const unsigned char *, 	unsigned char *         "unsigned char *"
%typemap(objctype) const short *,				short *                 "short *"
%typemap(objctype) const unsigned short *,	unsigned short *        "unsigned short *"
%typemap(objctype) const int *,		    	int *                   "int *"
%typemap(objctype) const unsigned int *,		unsigned int *          "unsigned int *"
%typemap(objctype) const long *,				long *                  "long *"
%typemap(objctype) const unsigned long *, 	unsigned long *         "unsigned long  *"
%typemap(objctype) const long long *, 		long long *             "long long *"
%typemap(objctype) const unsigned long long *,unsigned long long *    "unsigned long long  *"
%typemap(objctype) const float *, 			float *                 "float *"
%typemap(objctype) const double *,  			double *                "double *"

// C/C++ Pointers are treated as  as pointers in ObjectiveC
%typemap(objctype) SWIGTYPE *                           "$objcclassname*" 

// Arrays to non-primitive types
%typemap(objctype) SWIGTYPE []                          "$objcclassname*"

// Pointer to a class member
%typemap(objctype) SWIGTYPE (CLASS::*)                  "$objcclassname*"  

// References to non-primitive types
%typemap(objctype) SWIGTYPE &                           "$objcclassname*"
%typemap(objctype) SWIGTYPE *const&                     "$*objcclassname"

// Function pointers
%typemap(objctype) SWIGTYPE ((*)(ANY))                  "$objcclassname*"


/* 
 * OBJCIN TYPEMAPS: Used for "in" arguments type conversions from ObjectiveC(proxy) layer to ObjectiveC++(wrapper) layer.
 */

// Primary types
%typemap(objcin) bool "$objcinput" 

%typemap(objcin) char, 
             signed char, 
             unsigned char, 
             short, 
             unsigned short, 
             int, 
             unsigned int, 
             long, 
             unsigned long, 
             long long, 
             unsigned long long,
             float, 
             double
"$objcinput"

// No "objcin" for void
%typemap(objcin) void ""

// References: are treated as pointers in the proxy layer (ObjectiveC)
%typemap(objcin) const bool &,                  bool &, 
                 const char &,  		char &,
	     	 const signed char &, 		signed char &,
	         const unsigned char &, 	unsigned char &,
		     const short &,				short &,
		     const unsigned short &,	unsigned short &,
		     const int &,		    	int &,
		     const unsigned int &,		unsigned int &,
			 const long &,				long &,
	     	 const unsigned long &, 	unsigned long &,
	     	 const long long &, 		long long &,
	     	 const unsigned long long &,unsigned long long &,
	      	 const float &, 			float &,
	      	 const double &,  			double &
"$objcinput"

// C/C++ pointers to primitive types are treated as is in the Proxy layer.
%typemap(objcin)const bool *,              bool *,
             const char *,  			char *,
	     	 const signed char *, 		signed char *,
	         const unsigned char *, 	unsigned char *,
		     const short *,				short *,
		     const unsigned short *,	unsigned short *,
		     const int *,		    	int *,
		     const unsigned int *,		unsigned int *,
			 const long *,				long &,
	     	 const unsigned long *, 	unsigned long &,
	     	 const long long *, 		long long *,
	     	 const unsigned long long *,unsigned long long *,
	      	 const float *, 			float *,
	      	 const double *,  			double *
"$objcinput"

//C strings:
%typemap(objcin) char *, char[ANY], char[]  "$objcinput"
%typemap(objcin) char *&                    "$objcinput"

// Objects passed by value: Convert from an ObjectiveC pointer to the ObjectiveC++ void* pointer.
%typemap(objcin) SWIGTYPE "[$objcinput getCptr]"

// C/C++ Pointers, primary and object, are exported as ObjectiveC pointers
%typemap(objcin) SWIGTYPE *, SWIGTYPE & "[$objcinput getCptr]"
%typemap(objcin) SWIGTYPE "[$objcinput getCptr]"

// Pointer to a class member will be passed as void*, convert appropriately
%typemap(objcin) SWIGTYPE (CLASS::*) "" 

%typemap(objcin) SWIGTYPE *const& "[$objcinput getCptr]" 

/*
 * OBJCOUT TYPEMAPS: Used for return-type type conversions: ObjectiveC++(wrapper) to ObjectiveC(proxy)
 */

// Primary types are exported as ObjectiveC primary types
%typemap(objcout) char,
	      signed char,
	      unsigned char,
	      short,
	      unsigned short,
	      int,
	      unsigned int,
	      long,
	      unsigned long,
	      long long,
	      unsigned long long,
	      float,
	      double
%{  $1_ltype ret = $imcall;
    return ret; %}

%typemap(objcout) bool
%{  bool ret = $imcall;
    return (ret)? YES:NO; %}

%typemap(objcout) void "$imcall;"

%typemap(objcout) const bool &,         bool &,
             const char &,  			char &,
	     	 const signed char &, 		signed char &,
	         const unsigned char &, 	unsigned char &,
		     const short &,				short &,
		     const unsigned short &,	unsigned short &,
		     const int &,		    	int &,
		     const unsigned int &,		unsigned int &,
			 const long &,				long &,
	     	 const unsigned long &, 	unsigned long &,
	     	 const long long &, 		long long &,
	     	 const unsigned long long &,unsigned long long &,
	      	 const float &, 			float &,
	      	 const double &,  			double &
%{  $1_ltype ret = $imcall;
    return ret; %}


%typemap(objcout)const bool *,              bool *,
             const char *,  			char *,
	     	 const signed char *, 		signed char *,
	         const unsigned char *, 	unsigned char *,
		     const short *,				short *,
		     const unsigned short *,	unsigned short *,
		     const int *,		    	int *,
		     const unsigned int *,		unsigned int *,
			 const long *,				long &,
	     	 const unsigned long *, 	unsigned long &,
	     	 const long long *, 		long long *,
	     	 const unsigned long long *,unsigned long long *,
	      	 const float *, 			float *,
	      	 const double *,  			double *
%{  $1_ltype ret = $imcall;
    return ret; %}

// C strings: 
%typemap(objcout)const char *,char * 
%{  NSString *ret = $imcall;
    return ret; %}

%typemap(objcout) char *& 
%{  NSString *ret = $imcall;
    return ret; %}

%typemap(objcout) char[ANY], char[] 
%{  NSString *ret = $imcall;
    return ret; %}

// Objects returned by value: Convert the void* pointer to the ObjectiveC pointer.
// Here, for now, we presume that the returned C++ pointers will not have to be deleted by the client directly
// As such, we mark swigOwnCObject as NO. This has to be reviewed again.
%typemap(objcout) SWIGTYPE
%{   void* cPtr = $imcall;
     $objcclassname* ret = nil;
     if(cPtr) {
        ret = [[[$objcclassname alloc] initWithCptr:cPtr swigOwnCObject:NO] autorelease];
     }
    return ret; %}

// Pointer objects are returned as ObjectiveC pointers
// Here, for now, we presume that the returned C++ pointers will not have to be deleted by the client directly
// As such, we mark swigOwnCObject as NO. This has to be reviewed again.
%typemap(objcout) SWIGTYPE &
%{   void* cPtr = $imcall;
     $objcclassname* ret = nil;
     if(cPtr) {
        ret = [[[$objcclassname alloc] initWithCptr:cPtr swigOwnCObject:NO] autorelease];
     }
    return ret; %}
	
%typemap(objcout) SWIGTYPE *
%{   void* cPtr = $imcall;
     $objcclassname* ret = nil;
     if(cPtr) {
        ret = [[[$objcclassname alloc] initWithCptr:cPtr swigOwnCObject:NO] autorelease];
     }
    return ret; %}
    
// C function pointer
%typemap(objcout) SWIGTYPE ((*)(ANY)) 
%{   void* cPtr = $imcall;
     $objcclassname* ret = nil;
     if(cPtr) {
        ret = [[[$objcclassname alloc] initWithCptr:cPtr swigOwnCObject:NO] autorelease];
     }
    return ret; %}
    
%typemap(objcvarout) SWIGTYPE ((*)(ANY)) 
%{ $objcclassname* $objcvarname = [[[$objcclassname alloc] initWithCptr:($imcall) swigOwnCObject:NO] autorelease]; %}

// Pointer to a class member will be returned as id
%typemap(objcout) SWIGTYPE (CLASS::*) 
%{   void* cPtr = $imcall;
     $objcclassname* ret = nil;
     if(cPtr) {
        ret = [[[$objcclassname alloc] initWithCptr:cPtr swigOwnCObject:NO] autorelease];
     }
    return ret; %}

%typemap(objcout) SWIGTYPE *const& 
%{   void* cPtr = $imcall;
     $objcclassname* ret = nil;
     if(cPtr) {
        ret = [[[$objcclassname alloc] initWithCptr:cPtr swigOwnCObject:NO] autorelease];
     }
    return ret; %}
 
/* apply typemaps */
// Treat references to arrays like like references to a single element.
%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
%apply unsigned long { size_t };
%apply const unsigned long & { const size_t & };

/* Additional typemaps */
// Typemaps containing ObjectiveC code used when generating ObjectiveC proxy classes.
%include <objcproxycode.swg>

// Typemaps for handling enums
%include <objcenums.swg>

// ObjectiveC runtime support code.
%include <objcruntime.swg>

// List of all reserved ObjectiveC keywords.
%include <objckw.swg>