Added functions to provide a cleaner enum and flags initialization.

The functions are:

Shiboken::Enum::createGlobalEnum()
Shiboken::Enum::createScopedEnum()
Shiboken::Enum::createGlobalEnumItem()
Shiboken::Enum::createScopedEnumItem()

Also updated the generator to make use of them.

2 files changed, 110 insertions, 0 deletions

diff --git a/libshiboken/sbkenum.cpp b/libshiboken/sbkenum.cpp
index e128a059a..e05f5cdad 100644
--- a/libshiboken/sbkenum.cpp
+++ b/libshiboken/sbkenum.cpp
@@ -21,6 +21,7 @@
  */
 
 #include "sbkenum.h"
+#include "basewrapper.h"
 #include <string.h>
 #include <cstring>
 #include <list>
@@ -175,6 +176,80 @@ PyObject* getEnumItemFromValue(PyTypeObject* enumType, long itemValue)
     return 0;
 }
 
+static PyTypeObject* createEnum(const char* fullName, const char* cppName, PyTypeObject* flagsType)
+{
+    PyTypeObject* enumType = newTypeWithName(fullName, cppName);
+    if (flagsType) {
+        if (PyType_Ready(flagsType) < 0)
+            return 0;
+        enumType->tp_as_number = flagsType->tp_as_number;
+    }
+    if (PyType_Ready(enumType) < 0)
+        return 0;
+    return enumType;
+}
+
+PyTypeObject* createGlobalEnum(PyObject* module, const char* name, const char* fullName, const char* cppName, PyTypeObject* flagsType)
+{
+    PyTypeObject* enumType = createEnum(fullName, cppName, flagsType);
+    if (enumType) {
+        if (PyModule_AddObject(module, name, (PyObject*)enumType) < 0)
+            return 0;
+    }
+    if (flagsType) {
+        if (PyModule_AddObject(module, flagsType->tp_name, (PyObject*)flagsType) < 0)
+            return 0;
+    }
+    return enumType;
+}
+
+PyTypeObject* createScopedEnum(SbkObjectType* scope, const char* name, const char* fullName, const char* cppName, PyTypeObject* flagsType)
+{
+    PyTypeObject* enumType = createEnum(fullName, cppName, flagsType);
+    if (enumType) {
+        if (PyDict_SetItemString(scope->super.ht_type.tp_dict, name, (PyObject*)enumType) < 0)
+            return 0;
+    }
+    if (flagsType) {
+        if (PyDict_SetItemString(scope->super.ht_type.tp_dict, flagsType->tp_name, (PyObject*)flagsType) < 0)
+            return 0;
+    }
+    return enumType;
+}
+
+static PyObject* createEnumItem(PyTypeObject* enumType, const char* itemName, long itemValue)
+{
+    PyObject* enumItem = newItem(enumType, itemValue, itemName);
+    if (PyDict_SetItemString(enumType->tp_dict, itemName, enumItem) < 0)
+        return 0;
+    Py_DECREF(enumItem);
+    return enumItem;
+}
+
+bool createGlobalEnumItem(PyTypeObject* enumType, PyObject* module, const char* itemName, long itemValue)
+{
+    PyObject* enumItem = createEnumItem(enumType, itemName, itemValue);
+    if (enumItem) {
+        if (PyModule_AddObject(module, itemName, enumItem) < 0)
+            return false;
+        Py_DECREF(enumItem);
+        return true;
+    }
+    return false;
+}
+
+bool createScopedEnumItem(PyTypeObject* enumType, SbkObjectType* scope, const char* itemName, long itemValue)
+{
+    PyObject* enumItem = createEnumItem(enumType, itemName, itemValue);
+    if (enumItem) {
+        if (PyDict_SetItemString(scope->super.ht_type.tp_dict, itemName, enumItem) < 0)
+            return false;
+        Py_DECREF(enumItem);
+        return true;
+    }
+    return false;
+}
+
 PyObject* newItem(PyTypeObject* enumType, long itemValue, const char* itemName)
 {
     bool newValue = true;
diff --git a/libshiboken/sbkenum.h b/libshiboken/sbkenum.h
index c61afed91..52a0b6ffc 100644
--- a/libshiboken/sbkenum.h
+++ b/libshiboken/sbkenum.h
@@ -30,6 +30,7 @@ extern "C"
 {
 
 extern LIBSHIBOKEN_API PyTypeObject SbkEnumType_Type;
+struct SbkObjectType;
 
 } // extern "C"
 
@@ -43,6 +44,40 @@ inline bool isShibokenEnum(PyObject* pyObj)
 
 namespace Enum
 {
+    /**
+     *  Creates a new enum type (and its flags type, if any is given)
+     *  and registers it to Python and adds it to \p module.
+     *  \param module       Module to where the new enum type will be added.
+     *  \param name         Name of the enum.
+     *  \param fullName     Name of the enum that includes all scope information (e.g.: "module.Enum").
+     *  \param cppName      Full qualified C++ name of the enum.
+     *  \param flagsType    Optional Python type for the flags associated with the enum.
+     *  \return The new enum type or NULL if it fails.
+     */
+    LIBSHIBOKEN_API PyTypeObject* createGlobalEnum(PyObject* module,
+                                                   const char* name,
+                                                   const char* fullName,
+                                                   const char* cppName,
+                                                   PyTypeObject* flagsType = 0);
+    /// This function does the same as createGlobalEnum, but adds the enum to a Shiboken type or namespace.
+    LIBSHIBOKEN_API PyTypeObject* createScopedEnum(SbkObjectType* scope,
+                                                   const char* name,
+                                                   const char* fullName,
+                                                   const char* cppName,
+                                                   PyTypeObject* flagsType = 0);
+
+    /**
+     *  Creates a new enum item for a given enum type and adds it to \p module.
+     *  \param enumType  Enum type to where the new enum item will be added.
+     *  \param module    Module to where the enum type of the new enum item belongs.
+     *  \param itemName  Name of the enum item.
+     *  \param itemValue Numerical value of the enum item.
+     *  \return true if everything goes fine, false if it fails.
+     */
+    LIBSHIBOKEN_API bool createGlobalEnumItem(PyTypeObject* enumType, PyObject* module, const char* itemName, long itemValue);
+    /// This function does the same as createGlobalEnumItem, but adds the enum to a Shiboken type or namespace.
+    LIBSHIBOKEN_API bool createScopedEnumItem(PyTypeObject* enumType, SbkObjectType* scope, const char* itemName, long itemValue);
+
     LIBSHIBOKEN_API PyObject* newItem(PyTypeObject* enumType, long itemValue, const char* itemName = 0);
 
     LIBSHIBOKEN_API PyTypeObject* newType(const char* name); //Deprecated use 'newTypeWithName'