Moved functionality from a couple of write function to ones that return strings.

The methods writeToCppConversion and writeToPythonConversion now use the
services of cpythonToCppConversionFunction and cpythonToPythonConversionFunction.

2 files changed, 46 insertions, 35 deletions

diff --git a/generator/shibokengenerator.cpp b/generator/shibokengenerator.cpp
index e723b6f5e..ff7ad4b5b 100644
--- a/generator/shibokengenerator.cpp
+++ b/generator/shibokengenerator.cpp
@@ -576,31 +576,19 @@ void ShibokenGenerator::writeBaseConversion(QTextStream& s, const AbstractMetaTy
 void ShibokenGenerator::writeToPythonConversion(QTextStream& s, const AbstractMetaType* type,
                                                 const AbstractMetaClass* context, const QString& argumentName)
 {
-    if (!type)
-        return;
-
-    // exclude const on Objects
-    Options flags = getConverterOptions(type);
-    writeBaseConversion(s, type, context, flags);
-    s << "toPython";
-
-    if (!argumentName.isEmpty())
-        s << '(' << argumentName << ')';
+    s << cpythonToPythonConversionFunction(type, context) << '(' << argumentName << ')';
 }
 
 void ShibokenGenerator::writeToCppConversion(QTextStream& s, const AbstractMetaClass* metaClass,
                                              const QString& argumentName)
 {
-    writeBaseConversion(s, metaClass->typeEntry());
-    s << "toCpp(" << argumentName << ')';
+    s << cpythonToCppConversionFunction(metaClass) << '(' << argumentName << ')';
 }
 
 void ShibokenGenerator::writeToCppConversion(QTextStream& s, const AbstractMetaType* type,
-                                             const AbstractMetaClass* context, const QString& argumentName,
-                                             Options options)
+                                             const AbstractMetaClass* context, const QString& argumentName)
 {
-    writeBaseConversion(s, type, context, options);
-    s << "toCpp(" << argumentName << ')';
+    s << cpythonToCppConversionFunction(type, context) << '(' << argumentName << ')';
 }
 
 bool ShibokenGenerator::shouldRejectNullPointerArgument(const AbstractMetaFunction* func, int argIndex)
@@ -907,11 +895,10 @@ QString ShibokenGenerator::cpythonCheckFunction(const AbstractMetaType* metaType
         return genericNumberType ? QString("SbkNumber_Check") : QString("%1_Check").arg(baseName);
 
     baseName.clear();
-    QTextStream s(&baseName);
+    QTextStream b(&baseName);
     // exclude const on Objects
     Options flags = getConverterOptions(metaType);
-    writeBaseConversion(s, metaType, 0, flags);
-    s.flush();
+    writeBaseConversion(b, metaType, 0, flags);
     return QString("%1checkType").arg(baseName);
 }
 
@@ -931,9 +918,8 @@ QString ShibokenGenerator::cpythonCheckFunction(const TypeEntry* type, bool gene
         return genericNumberType ? "SbkNumber_Check" : baseName+"_Check";
 
     baseName.clear();
-    QTextStream s(&baseName);
-    writeBaseConversion(s, type);
-    s.flush();
+    QTextStream b(&baseName);
+    writeBaseConversion(b, type);
     return QString("%1checkType").arg(baseName);
 }
 
@@ -974,13 +960,10 @@ QString ShibokenGenerator::cpythonIsConvertibleFunction(const TypeEntry* type, b
         return guessCPythonIsConvertible(type->name());
 
     QString baseName;
-    QTextStream s(&baseName);
-    writeBaseConversion(s, type);
-    s << "isConvertible";
-    s.flush();
-    return baseName;
+    QTextStream b(&baseName);
+    writeBaseConversion(b, type);
+    return QString("%1isConvertible").arg(baseName);
 }
-
 QString ShibokenGenerator::cpythonIsConvertibleFunction(const AbstractMetaType* metaType, bool genericNumberType)
 {
     QString customCheck;
@@ -998,12 +981,36 @@ QString ShibokenGenerator::cpythonIsConvertibleFunction(const AbstractMetaType*
         return genericNumberType ? QString("SbkNumber_Check") : QString("%1_Check").arg(baseName);
 
     baseName.clear();
-    QTextStream s(&baseName);
-    writeBaseConversion(s, metaType, 0);
-    s.flush();
+    QTextStream b(&baseName);
+    writeBaseConversion(b, metaType);
     return QString("%1isConvertible").arg(baseName);
 }
 
+QString ShibokenGenerator::cpythonToCppConversionFunction(const AbstractMetaClass* metaClass)
+{
+    QString base;
+    QTextStream b(&base);
+    writeBaseConversion(b, metaClass->typeEntry());
+    return QString("%1toCpp").arg(base);
+}
+QString ShibokenGenerator::cpythonToCppConversionFunction(const AbstractMetaType* type, const AbstractMetaClass* context)
+{
+    QString base;
+    QTextStream b(&base);
+    writeBaseConversion(b, type, context);
+    return QString("%1toCpp").arg(base);
+}
+
+QString ShibokenGenerator::cpythonToPythonConversionFunction(const AbstractMetaType* type, const AbstractMetaClass* context)
+{
+    // exclude const on Objects
+    Options flags = getConverterOptions(type);
+    QString base;
+    QTextStream b(&base);
+    writeBaseConversion(b, type, context, flags);
+    return QString("%1toPython").arg(base);
+}
+
 QString ShibokenGenerator::argumentString(const AbstractMetaFunction *func,
                                           const AbstractMetaArgument *argument,
                                           Options options) const
diff --git a/generator/shibokengenerator.h b/generator/shibokengenerator.h
index e920f7f9f..6890e9203 100644
--- a/generator/shibokengenerator.h
+++ b/generator/shibokengenerator.h
@@ -226,13 +226,12 @@ public:
     const AbstractMetaClass* getMultipleInheritingClass(const AbstractMetaClass* metaClass);
 
     void writeBaseConversion(QTextStream& s, const AbstractMetaType* type,
-                             const AbstractMetaClass* context, Options options = NoOption);
+                             const AbstractMetaClass* context = 0, Options options = NoOption);
     /// Simpler version of writeBaseConversion, uses only the base name of the type.
     void writeBaseConversion(QTextStream& s, const TypeEntry* type);
     void writeToPythonConversion(QTextStream& s, const AbstractMetaType* type,
-                                 const AbstractMetaClass* context, const QString& argumentName = QString());
-    void writeToCppConversion(QTextStream& s, const AbstractMetaType* type,
-                              const AbstractMetaClass* context, const QString& argumentName, Options options = NoOption);
+                                 const AbstractMetaClass* context, const QString& argumentName);
+    void writeToCppConversion(QTextStream& s, const AbstractMetaType* type, const AbstractMetaClass* context, const QString& argumentName);
     void writeToCppConversion(QTextStream& s, const AbstractMetaClass* metaClass, const QString& argumentName);
 
     /// Returns true if the argument is a pointer that rejects NULL values.
@@ -319,6 +318,11 @@ public:
         return cpythonIsConvertibleFunction(metaArg->type(), genericNumberType);
     }
     QString guessCPythonIsConvertible(const QString& type);
+
+    QString cpythonToCppConversionFunction(const AbstractMetaClass* metaClass);
+    QString cpythonToCppConversionFunction(const AbstractMetaType* type, const AbstractMetaClass* context = 0);
+    QString cpythonToPythonConversionFunction(const AbstractMetaType* type, const AbstractMetaClass* context = 0);
+
     QString cpythonFunctionName(const AbstractMetaFunction* func);
     QString cpythonMethodDefinitionName(const AbstractMetaFunction* func);
     QString cpythonGettersSettersDefinitionName(const AbstractMetaClass* metaClass);