Add C++ GetArrayDataTypeUseCase

cgen-lib/src/main/kotlin/ce/formatters/CodeFormatterCxxUseCaseImpl.kt

@@ -1,11 +1,16 @@
 package ce.formatters
 
+import ce.defs.RValue
 import generators.obj.abstractSyntaxTree.Leaf
 import generators.obj.abstractSyntaxTree.Node
 import generators.obj.abstractSyntaxTree.addSeparator
 import generators.obj.abstractSyntaxTree.addSub
+import generators.obj.abstractSyntaxTree.insertSub
 import generators.obj.syntaxParseTree.EnumNode
+import generators.obj.syntaxParseTree.Keyword
 import generators.obj.syntaxParseTree.Separator
+import generators.obj.syntaxParseTree.Space
+import generators.obj.syntaxParseTree.VariableName
 import javax.inject.Inject
 
 class CodeFormatterCxxUseCaseImpl @Inject constructor(codeStyleRepo: CodeStyleRepo) :
@@ -38,4 +43,20 @@ class CodeFormatterCxxUseCaseImpl @Inject constructor(codeStyleRepo: CodeStyleRe
             outputParent.addSeparator(";")
         }
     }
+
+    override fun processEnumNode(input: EnumNode, parent: Node?, indent: Int, next: Leaf?, prev: Leaf?): EnumNode {
+        val result = super.processEnumNode(input, parent, indent, next, prev)
+        // make sure that we have spaces between name, = and rvalue
+        if (result.subs.size >= 3) {
+            val varName = result.subs[0]
+            val eq = result.subs[1]
+            val rValue = result.subs[2]
+            if (varName is VariableName && eq is Keyword &&  rValue is RValue) {
+                // add spaces
+                result.insertSub(2, Space())
+                result.insertSub(1, Space())
+            }
+        }
+        return result
+    }
 }

cgen-lib/src/main/kotlin/ce/repository/GeneratorsRepo.kt

@@ -7,23 +7,11 @@ import ce.formatters.CodeFormatterJavaUseCaseImpl
 import ce.formatters.CodeFormatterKotlinUseCaseImpl
 import ce.formatters.CodeFormatterUseCase
 import ce.settings.Project
-import generators.cpp.CppConstantsBlockGenerator
-import generators.cpp.CppDataClassGenerator
-import generators.cpp.CppEnumGenerator
-import generators.cpp.CppFileGenerator
-import generators.cpp.CppInterfaceGenerator
-import generators.java.JavaConstantsGenerator
-import generators.java.JavaDataClassGenerator
-import generators.java.JavaEnumGenerator
-import generators.java.JavaFileGenerator
-import generators.java.JavaInterfaceGenerator
+import generators.cpp.*
+import generators.java.*
+import generators.kotlin.*
 import generators.kotlin.GetArrayDataTypeUseCase
 import generators.kotlin.GetTypeNameUseCase
-import generators.kotlin.KotlinEnumGenerator
-import generators.kotlin.KotlinFileGenerator
-import generators.kotlin.KotlinInterfaceGenerator
-import generators.kotlin.KtConstantsGenerator
-import generators.kotlin.KtDataClassGenerator
 import generators.kotlin.PrepareRightValueUseCase
 import generators.obj.MetaGenerator
 import generators.obj.PrepareFilesListUseCaseImpl
@@ -132,19 +120,25 @@ class GeneratorsRepo(
                 }
 
                 Target.Cpp -> {
-                    val arrayDataType = GetArrayDataTypeUseCase()
-                    val dataTypeToString = GetTypeNameUseCase(
+                    val arrayDataType = generators.cpp.GetArrayDataTypeUseCase()
+                    val dataTypeToString = generators.cpp.GetTypeNameUseCase(
                         arrayDataType = arrayDataType
                     )
-                    val prepareRightValueUseCase = PrepareRightValueUseCase(
+                    val prepareRightValueUseCase = generators.cpp.PrepareRightValueUseCase(
                         getTypeNameUseCase = dataTypeToString
                     )
                     mapOf(
-                        ConstantsEnum::class.java to CppEnumGenerator(addBlockUseCase),
+                        ConstantsEnum::class.java to CppEnumGenerator(
+                            addBlockDefaultsUseCase = addBlockUseCase,
+                            prepareRightValueUseCase = prepareRightValueUseCase
+                        ),
                         ConstantsBlock::class.java to CppConstantsBlockGenerator(
                             addBlockDefaultsUseCase = addBlockUseCase,
                             prepareRightValueUseCase = prepareRightValueUseCase),
-                        DataClass::class.java to CppDataClassGenerator(addBlockUseCase),
+                        DataClass::class.java to CppDataClassGenerator(
+                            addBlockDefaultsUseCase = addBlockUseCase,
+                            prepareRightValueUseCase = prepareRightValueUseCase,
+                            dataTypeToString = dataTypeToString),
                         InterfaceDescription::class.java to CppInterfaceGenerator(addBlockUseCase)
                     )
                 }

cgen-lib/src/main/kotlin/generators/cpp/CppConstantsBlockGenerator.kt

@@ -1,7 +1,6 @@
 package generators.cpp
 
 import ce.domain.usecase.add.AddRegionDefaultsUseCase
-import generators.kotlin.PrepareRightValueUseCase
 import generators.obj.AutoincrementField
 import generators.obj.TransformBlockUseCase
 import generators.obj.abstractSyntaxTree.ConstantDesc

cgen-lib/src/main/kotlin/generators/cpp/CppDataClassGenerator.kt

@@ -2,26 +2,13 @@ package generators.cpp
 
 import ce.domain.usecase.add.AddRegionDefaultsUseCase
 import generators.obj.TransformBlockUseCase
-import generators.obj.abstractSyntaxTree.DataClass
-import generators.obj.abstractSyntaxTree.DataField
-import generators.obj.abstractSyntaxTree.addCommentLine
-import generators.obj.abstractSyntaxTree.addDatatype
-import generators.obj.abstractSyntaxTree.addKeyword
-import generators.obj.abstractSyntaxTree.addOutBlock
-import generators.obj.abstractSyntaxTree.addSub
-import generators.obj.abstractSyntaxTree.addVarName
-import generators.obj.abstractSyntaxTree.findOrCreateSub
-import generators.obj.abstractSyntaxTree.findOrNull
-import generators.obj.abstractSyntaxTree.getParentPath
-import generators.obj.syntaxParseTree.CommentsBlock
-import generators.obj.syntaxParseTree.FieldNode
-import generators.obj.syntaxParseTree.FileData
-import generators.obj.syntaxParseTree.ImportsBlock
-import generators.obj.syntaxParseTree.NamespaceBlock
-import generators.obj.syntaxParseTree.RegionImpl
+import generators.obj.abstractSyntaxTree.*
+import generators.obj.syntaxParseTree.*
 
 class CppDataClassGenerator(
     private val addBlockDefaultsUseCase: AddRegionDefaultsUseCase,
+    private val prepareRightValueUseCase: PrepareRightValueUseCase,
+    private val dataTypeToString: GetTypeNameUseCase,
 ) : TransformBlockUseCase<DataClass> {
 
     override fun invoke(blockFiles: List<FileData>, desc: DataClass) {
@@ -43,11 +30,15 @@ class CppDataClassGenerator(
                 desc.subs.forEach { leaf ->
                     if (leaf is DataField) {
                         addSub(FieldNode().apply {
-                            addDatatype(Types.typeTo(header, leaf.getType()))
+                            addDatatype(dataTypeToString.typeTo(header, leaf.getType()))
                             addVarName(leaf.name)
                             if (leaf.getValue().isDefined()) {
                                 addKeyword("=")
-                                addSub(Types.toValue(leaf.getType(), leaf.getValue()))
+                                val rValue = prepareRightValueUseCase.toRightValue(
+                                    dataField = leaf,
+                                    fileData = header
+                                )
+                                addSub(rValue)
                             }
                         })
                     }

cgen-lib/src/main/kotlin/generators/cpp/CppEnumGenerator.kt

@@ -10,7 +10,6 @@ import generators.obj.abstractSyntaxTree.addCommentLine
 import generators.obj.abstractSyntaxTree.addEnumLeaf
 import generators.obj.abstractSyntaxTree.addKeyword
 import generators.obj.abstractSyntaxTree.addOutBlock
-import generators.obj.abstractSyntaxTree.addSeparator
 import generators.obj.abstractSyntaxTree.addSub
 import generators.obj.abstractSyntaxTree.addVarName
 import generators.obj.abstractSyntaxTree.findOrNull
@@ -22,6 +21,7 @@ import generators.obj.syntaxParseTree.RegionImpl
 
 class CppEnumGenerator(
     private val addBlockDefaultsUseCase: AddRegionDefaultsUseCase,
+    private val prepareRightValueUseCase: PrepareRightValueUseCase,
 ) : TransformBlockUseCase<ConstantsEnum> {
 
     override fun invoke(files: List<FileData>, desc: ConstantsEnum) {
@@ -45,58 +45,22 @@ class CppEnumGenerator(
             desc.subs.forEach { leaf ->
                 if (leaf is DataField) {
                     val it = leaf
-
                     if (withRawValues) {
-                        addEnumLeaf(it.name).apply {
-                            autoIncrement(it)
+                        autoIncrement(it)
+                        val rValue = prepareRightValueUseCase.toRightValue(
+                            dataField = it,
+                            fileData = headerFile
+                        )
+                        addEnumLeaf("").apply {
                             addVarName(it.name)
                             addKeyword("=")
-                            addSub(Types.toValue(it.getType(), it.getValue()))
+                            addSub(rValue)
                         }
                     } else {
                         addEnumLeaf(it.name)
                     }
                 }
             }
         }
-        region.addSeparator(";")
-
-
-//
-//        desc.subs.forEach {
-//            if (it is ConstantDesc) {
-//                autoIncrement.invoke(it)
-//                region.addSub(
-//                    ConstantLeaf().apply {
-//                        addKeyword("const")
-//                        addDatatype(Types.typeTo(headerFile, it.type))
-//                        addVarName(it.name)
-//                        addKeyword("=")
-//                        addRValue(Types.toValue(it.type, it.value))
-//                        addKeyword(";")
-//                    }
-//                )
-//            }
-//        }
-
-
-//            classDefinition.append("enum ${desc.name} {").append(fileGenerator.newLine())
-//            val autoIncrement = AutoincrementField()
-//            desc.subs.forEach { leaf ->
-//                val it = leaf as DataField
-//                putTabs(classDefinition, 1)
-//
-//                if (withRawValues) {
-//                    autoIncrement.invoke(it)
-//                    classDefinition.append(it.name);
-//                    classDefinition.append(" = ${Types.toValue(this, it.type, it.value)},")
-//                    classDefinition.append(fileGenerator.newLine())
-//                } else {
-//                    classDefinition.append("${it.name},${fileGenerator.newLine()}");
-//                }
-//            }
-//            appendClassDefinition(this, "};");
-
     }
-
 }

cgen-lib/src/main/kotlin/generators/cpp/GetArrayDataTypeUseCase.kt

@@ -0,0 +1,23 @@
+package generators.cpp
+
+import ce.defs.DataType
+
+class GetArrayDataTypeUseCase {
+    fun getArrayType(type: DataType): String =
+        when (type) {
+            DataType.int8 -> "std::vector<int8_t>"
+            DataType.uint8 -> "std::vector<uint8_t>"
+            DataType.int16 -> "std::vector<int16_t>"
+            DataType.int32 -> "std::vector<int32_t>"
+            DataType.int64 -> "std::vector<int64_t>"
+            DataType.uint16 -> "std::vector<uint16_t>"
+            DataType.uint32 -> "std::vector<uint32_t>"
+            DataType.uint64 -> "std::vector<uint64_t>"
+            DataType.float32 -> "std::vector<float>"
+            DataType.float64 -> "std::vector<double>"
+            DataType.string -> "std::vector<std::string>"
+            is DataType.userClass -> "std::vector<${type.path}>"
+            is DataType.custom -> "std::vector<${type.block.name}>"
+            else -> "ktQQTP_array_$type"
+        }
+}

cgen-lib/src/main/kotlin/generators/cpp/GetTypeNameUseCase.kt

@@ -0,0 +1,46 @@
+package generators.cpp
+
+import ce.defs.DataType
+import generators.obj.abstractSyntaxTree.findOrCreateSub
+import generators.obj.abstractSyntaxTree.getParentPath
+import generators.obj.abstractSyntaxTree.getPath
+import generators.obj.syntaxParseTree.FileData
+import generators.obj.syntaxParseTree.ImportsBlock
+
+class GetTypeNameUseCase(
+    private val arrayDataType: GetArrayDataTypeUseCase
+) {
+    fun typeTo(file: FileData,
+               type: DataType
+    ) : String {
+        when (type) {
+            is DataType.custom ->
+                file.findOrCreateSub(ImportsBlock::class.java)
+                    .addInclude("${type.block.getParentPath()}.${type.block.name}");
+            else -> {}
+        }
+        val baseType = when (type) {
+            DataType.VOID -> "void"
+            DataType.int8, DataType.int8Nullable -> "int8_t"
+            DataType.int16, DataType.int16Nullable -> "int16_t"
+            DataType.int32, DataType.int32Nullable -> "int32_t"
+            DataType.int64, DataType.int64Nullable -> "int64_t"
+            DataType.uint8, DataType.uint8Nullable -> "uint8_t"
+            DataType.uint16, DataType.uint16Nullable -> "uint16_t"
+            DataType.uint32, DataType.uint32Nullable -> "uint32_t"
+            DataType.uint64, DataType.uint64Nullable -> "uint64_t"
+            DataType.float32, DataType.float32Nullable -> "float"
+            DataType.float64, DataType.float64Nullable -> "double"
+            DataType.bool, DataType.boolNullable -> "bool"
+
+            DataType.string, DataType.stringNullable -> "std::string"
+            is DataType.array -> arrayDataType.getArrayType(type.elementDataType)
+            is DataType.userClass -> type.path
+            is DataType.custom -> type.block.name
+            is DataType.userClassTest2 -> type.node.getPath()
+            else -> "ktQQTP_$type"
+        }
+        val result = if (type.canBeNull) "std::optional<$baseType>" else baseType
+        return result
+    }
+}

cgen-lib/src/main/kotlin/generators/cpp/PrepareRightValueUseCase.kt

@@ -3,13 +3,16 @@ package generators.cpp
 import ce.defs.DataType
 import ce.defs.DataValue
 import ce.defs.RValue
-import generators.kotlin.GetTypeNameUseCase
 import generators.obj.abstractSyntaxTree.DataField
+import generators.obj.abstractSyntaxTree.Input
 import generators.obj.abstractSyntaxTree.NewInstance
 import generators.obj.abstractSyntaxTree.addSub
+import generators.obj.syntaxParseTree.ArgumentNode
 import generators.obj.syntaxParseTree.Arguments
 import generators.obj.syntaxParseTree.Constructor
 import generators.obj.syntaxParseTree.FileData
+import generators.obj.syntaxParseTree.Keyword
+import generators.obj.syntaxParseTree.VariableName
 
 class PrepareRightValueUseCase(
     private val getTypeNameUseCase: GetTypeNameUseCase
@@ -67,7 +70,24 @@ class PrepareRightValueUseCase(
                     type = item.getType()
                 )
             ).apply {
-                addSub(Arguments())
+                val arguments = Arguments()
+                addSub(arguments)
+                item.subs
+                    .filter { it is Input }
+                    .forEach {
+                        val input = it as Input
+                        val argumentNode = ArgumentNode()
+                        arguments.addSub(
+                            argumentNode
+                        )
+                        argumentNode.addSub(
+                            toRightValue(
+                                type = input.getType(),
+                                value = input.getValue(),
+                                fileData = fileData
+                            )
+                        )
+                    }
             }
         )
         return result

cgen-lib/src/main/kotlin/generators/cpp/Types.kt

@@ -7,6 +7,7 @@ import generators.obj.abstractSyntaxTree.findOrCreateSub
 import generators.obj.syntaxParseTree.FileData
 import generators.obj.syntaxParseTree.ImportsBlock
 
+@Deprecated("Use GetTypeNameUseCase")
 object Types {
     fun typeTo(file: FileData,
                type: DataType

cgen-lib/src/main/kotlin/generators/kotlin/KotlinEnumGenerator.kt

@@ -40,16 +40,12 @@ class KotlinEnumGenerator(
                             addVarName("rawValue")
                             addKeyword(":")
                             addDatatype(dataTypeToString.typeTo(file, desc.defaultDataType))
-//                            addKeyword("=")
-//                            addRValue(Types.toValue(desc.type, desc.value))
                         })
-//                        addDataField("val rawValue : ${Types.typeTo(file, desc.defaultDataType)}", desc.defaultDataType)
                     }
                 }
                 desc.subs.forEach { leaf ->
                     if (leaf is DataField) {
                         val it = leaf
-
                         if (withRawValues) {
                             autoIncrement(it)
                             val rValue = prepareRightValueUseCase.toRightValue(

cgen-lib/src/main/kotlin/generators/obj/abstractSyntaxTree/Node.kt

@@ -67,6 +67,13 @@ fun <R : Leaf, T : Node> T.addSub(leaf: R): R {
     return leaf
 }
 
+fun <R : Leaf, T : Node> T.insertSub(idx: Int, leaf: R): R {
+    subs.add(idx, leaf)
+    leaf.setParent2(this)
+    (findParent(FileData::class) as FileData?)?.isDirty = true
+    return leaf
+}
+
 fun <R : Leaf, T : Node> T.addSubs(vararg leafs: R) {
     leafs.forEach {
         subs.add(it)