Enum typemaps taken out of csharp.swg.

New typemap files for the different C/C++ to C# enum wrapping approaches.


git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk@5920 626c5289-ae23-0410-ae9c-e8d60b6d4f22

SWIG/Lib/csharp/csharp.swg

@@ -84,10 +84,6 @@
 %typemap(imtype) SWIGTYPE & "IntPtr"
 %typemap(cstype) SWIGTYPE & "$csclassname"
 
-%typemap(ctype) enum SWIGTYPE "int"
-%typemap(imtype) enum SWIGTYPE "int"
-%typemap(cstype) enum SWIGTYPE "$csclassname"
-
 /* pointer to a class member */
 %typemap(ctype) SWIGTYPE (CLASS::*) "int"
 %typemap(imtype) SWIGTYPE (CLASS::*) "IntPtr"
@@ -111,8 +107,7 @@
              long long, 
              unsigned long long, 
              float, 
-             double, 
-             enum SWIGTYPE
+             double
 %{ $1 = ($1_ltype)$input; %}
 
 %typemap(out) bool               %{ $result = $1; %}
@@ -129,7 +124,6 @@
 %typemap(out) unsigned long long %{ $result = $1; %}
 %typemap(out) float              %{ $result = $1; %}
 %typemap(out) double             %{ $result = $1; %}
-%typemap(out) enum SWIGTYPE      %{ $result = $1; %}
 
 /* char * - treat as String */
 %typemap(in) char * %{ $1 = $input; %}
@@ -242,8 +236,7 @@ $1 = &temp; %}
     long, 
     const unsigned short &, 
     const int &, 
-    const long &,
-    enum SWIGTYPE
+    const long &
     ""
 
 %typecheck(SWIG_TYPECHECK_INT64) /* Java long */
@@ -299,10 +292,6 @@ $1 = &temp; %}
   SWIG_CSharpThrowException(SWIG_CSharpException, "C++ $1_type exception thrown");
 }
 
-%typemap(throws) enum SWIGTYPE {
-  SWIG_CSharpThrowException(SWIG_CSharpException, "C++ $1_type exception thrown");
-}
-
 %typemap(throws) char * {
   SWIG_CSharpThrowException(SWIG_CSharpException, $1);
 }
@@ -329,7 +318,6 @@ $1 = &temp; %}
                  char *,
                  char[ANY]
     "$csinput"
-%typemap(csin) enum SWIGTYPE "(int)$csinput"
 %typemap(csin) SWIGTYPE "$&csclassname.getCPtr($csinput)"
 %typemap(csin) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) "$csclassname.getCPtr($csinput)"
 
@@ -353,9 +341,6 @@ $1 = &temp; %}
                   char[ANY] {
     return $imcall;
   }
-%typemap(csout) enum SWIGTYPE {
-    return ($csclassname)$imcall;
-  }
 %typemap(csout) void {
     $imcall;
   }
@@ -395,10 +380,6 @@ $1 = &temp; %}
     get {
       return $imcall;
     } %}
-%typemap(csvarout) enum SWIGTYPE %{
-    get {
-      return ($csclassname)$imcall;
-    } %}
 
 %typemap(csvarout) void %{
     get {
@@ -420,7 +401,7 @@ $1 = &temp; %}
 
 /* Typemaps used for the generation of proxy and type wrapper class code */
 %typemap(csbase)                      SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
-%typemap(csclassmodifiers)            SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*), enum SWIGTYPE "public"
+%typemap(csclassmodifiers)            SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) "public"
 %typemap(cscode)                      SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) ""
 %typemap(csimports)                   SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE [], SWIGTYPE (CLASS::*) "\nusing System;\n"
 %typemap(csinterfaces)                SWIGTYPE "IDisposable"
@@ -460,7 +441,7 @@ $1 = &temp; %}
 
 /* C# specific directives */
 #define %csconst(flag)     %feature("cs:const","flag")
-#define %csenumint(flag)   %feature("cs:enumint","flag")
+#define %csenum(wrapapproach)   %feature("cs:enum","wrapapproach")
 #define %csmethodmodifiers %feature("cs:methodmodifiers")
 
 %pragma(csharp) moduleimports=%{
@@ -479,3 +460,7 @@ using System.Runtime.InteropServices;
 /* csharp keywords */
 /* please test and activate */
 //%include "csharpkw.swg"
+
+// Default enum handling
+%include "enums.swg"
+

SWIG/Lib/csharp/enums.swg

@@ -0,0 +1,32 @@
+/* -----------------------------------------------------------------------------
+ * Include this file in order for C/C++ enums to be wrapped by proper C# enums.
+ * Note that the PINVOKE layer handles the enum as an int.
+ * ----------------------------------------------------------------------------- */
+
+%typemap(ctype) enum SWIGTYPE "int"
+%typemap(imtype) enum SWIGTYPE "int"
+%typemap(cstype) enum SWIGTYPE "$csclassname"
+
+%typemap(in) enum SWIGTYPE %{ $1 = ($1_ltype)$input; %}
+%typemap(out) enum SWIGTYPE %{ $result = $1; %}
+
+%typecheck(SWIG_TYPECHECK_INT32) enum SWIGTYPE ""
+
+%typemap(throws) enum SWIGTYPE {
+  SWIG_CSharpThrowException(SWIG_CSharpException, "C++ $1_type exception thrown");
+}
+
+%typemap(csin) enum SWIGTYPE "(int)$csinput"
+%typemap(csout) enum SWIGTYPE {
+    return ($csclassname)$imcall;
+  }
+
+%typemap(csvarout) enum SWIGTYPE %{
+    get {
+      return ($csclassname)$imcall;
+    } %}
+
+%typemap(csclassmodifiers) enum SWIGTYPE "public enum"
+
+%csenum(proper);
+

SWIG/Lib/csharp/enumsimple.swg

@@ -0,0 +1,36 @@
+/* -----------------------------------------------------------------------------
+ * This file provides backwards compatible enum wrapping. SWIG versions 1.3.21
+ * and earlier wrapped global enums with constant integers in the module
+ * class. Enums declared within a C++ class were wrapped by constant integers
+ * in the Java proxy class.
+ * ----------------------------------------------------------------------------- */
+
+%typemap(ctype) enum SWIGTYPE "int"
+%typemap(imtype) enum SWIGTYPE "int"
+%typemap(cstype) enum SWIGTYPE "int"
+
+%typemap(in) enum SWIGTYPE %{ $1 = ($1_ltype)$input; %}
+%typemap(out) enum SWIGTYPE %{ $result = $1; %}
+
+%typecheck(SWIG_TYPECHECK_INT32) enum SWIGTYPE ""
+
+%typemap(throws) enum SWIGTYPE {
+  SWIG_CSharpThrowException(SWIG_CSharpException, "C++ $1_type exception thrown");
+}
+
+%typemap(csin) enum SWIGTYPE "$csinput"
+%typemap(csout) enum SWIGTYPE {
+    return $imcall;
+  }
+
+%typemap(csvarout) enum SWIGTYPE %{
+    get {
+      return $imcall;
+    } %}
+
+%typemap(csclassmodifiers) enum SWIGTYPE ""
+
+%typemap(csgetcptr) enum SWIGTYPE ""
+
+%csenum(simple);
+

SWIG/Lib/csharp/enumtypesafe.swg

@@ -0,0 +1,65 @@
+/* -----------------------------------------------------------------------------
+ * Include this file in order for C/C++ enums to be wrapped by the so called
+ * typesafe enum pattern. Each enum has an equivalent C# class named after the
+ * enum and each enum item is a static instance of this class.
+ * ----------------------------------------------------------------------------- */
+
+%typemap(ctype) enum SWIGTYPE "int"
+%typemap(imtype) enum SWIGTYPE "int"
+%typemap(cstype) enum SWIGTYPE "$csclassname"
+
+%typemap(in) enum SWIGTYPE %{ $1 = ($1_ltype)$input; %}
+%typemap(out) enum SWIGTYPE %{ $result = $1; %}
+
+%typecheck(SWIG_TYPECHECK_INT32) enum SWIGTYPE ""
+
+%typemap(throws) enum SWIGTYPE {
+  SWIG_CSharpThrowException(SWIG_CSharpException, "C++ $1_type exception thrown");
+}
+
+%typemap(csin) enum SWIGTYPE "$csinput.swigValue"
+%typemap(csout) enum SWIGTYPE {
+    return $csclassname.swigToEnum($imcall);
+  }
+
+%typemap(csvarout) enum SWIGTYPE %{
+    get {
+      return $csclassname.swigToEnum($imcall);
+    } %}
+
+%typemap(csclassmodifiers) enum SWIGTYPE "public class"
+
+/*
+ * The swigToEnum method is used to find the C# enum from a C++ enum integer value. The default one here takes 
+ * advantage of the fact that most enums do not have initial values specified, so the lookup is fast. If initial
+ * values are specified then a lengthy linear search through all possible enums might occur. Specific typemaps could be
+ * written to possibly optimise this lookup by taking advantage of characteristics peculiar to the targeted enum.
+ * The special variable, $enumvalues, is replaced with a comma separated list of all the enum values.
+ */
+%typemap(csgetcptr) enum SWIGTYPE %{
+  public readonly int swigValue;
+
+  public static $csclassname swigToEnum(int swigValue) {
+    if (swigValue < swigValues.Length && swigValues[swigValue].swigValue == swigValue)
+      return swigValues[swigValue];
+    for (int i = 0; i<swigValues.Length; i++)
+      if (swigValues[i].swigValue == swigValue)
+        return swigValues[i];
+    throw new System.ArgumentOutOfRangeException("No enum $csclassname with value " + swigValue);
+  }
+
+  private $csclassname() {
+    this.swigValue = next++;
+  }
+
+  private $csclassname(int swigValue) {
+    this.swigValue = swigValue;
+    next = swigValue+1;
+  }
+
+  private static $csclassname[] swigValues = { $enumvalues };
+  private static int next = 0;
+%}
+
+%csenum(typesafe);
+