C++ type use cases will update includes

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

@@ -10,11 +10,13 @@ import generators.obj.abstractSyntaxTree.addDatatype
 import generators.obj.abstractSyntaxTree.addKeyword
 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
 
@@ -26,6 +28,7 @@ class CppConstantsBlockGenerator(
     override fun invoke(blockFiles: List<FileData>, desc: ConstantsBlock) {
         val headerFile = blockFiles.find { it is CppHeaderFile }
             ?: throw java.lang.IllegalStateException("Can't find Header file for C++")
+        val imports = headerFile.findOrCreateSub(ImportsBlock::class.java)
 
         val namespace = headerFile.addSub(NamespaceBlock(desc.getParentPath()))
         val outBlock = namespace.addSub(RegionImpl(desc.name))
@@ -48,7 +51,11 @@ class CppConstantsBlockGenerator(
                         addDatatype(Types.typeTo(headerFile, it.getType()))
                         addVarName(it.name)
                         addKeyword("=")
-                        val rValue = prepareRightValueUseCase.toRightValue(it.getType(), it.getValue(), headerFile)
+                        val rValue = prepareRightValueUseCase.toRightValue(
+                            type = it.getType(),
+                            value = it.getValue(),
+                            importsBlock = imports
+                        )
                         addSub(rValue)
                     }
                 )

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

@@ -2,8 +2,23 @@ package generators.cpp
 
 import ce.domain.usecase.add.AddRegionDefaultsUseCase
 import generators.obj.TransformBlockUseCase
-import generators.obj.abstractSyntaxTree.*
-import generators.obj.syntaxParseTree.*
+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
 
 class CppDataClassGenerator(
     private val addBlockDefaultsUseCase: AddRegionDefaultsUseCase,
@@ -15,6 +30,7 @@ class CppDataClassGenerator(
         val header = blockFiles.find { it is CppHeaderFile }
             ?: throw java.lang.IllegalStateException("Can't find Header file for C++")
         header.findOrCreateSub(ImportsBlock::class.java)
+        val imports = header.findOrCreateSub(ImportsBlock::class.java)
 
         val namespace = header.addSub(NamespaceBlock(desc.getParentPath()))
 
@@ -30,13 +46,18 @@ class CppDataClassGenerator(
                 desc.subs.forEach { leaf ->
                     if (leaf is DataField) {
                         addSub(FieldNode().apply {
-                            addDatatype(dataTypeToString.typeTo(header, leaf.getType()))
+                            addDatatype(
+                                dataTypeToString.typeTo(
+                                    importsBlock = imports,
+                                    type = leaf.getType()
+                                )
+                            )
                             addVarName(leaf.name)
                             if (leaf.getValue().isDefined()) {
                                 addKeyword("=")
                                 val rValue = prepareRightValueUseCase.toRightValue(
                                     dataField = leaf,
-                                    fileData = header
+                                    importsBlock = imports
                                 )
                                 addSub(rValue)
                             }

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

@@ -12,10 +12,12 @@ 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.FileData
+import generators.obj.syntaxParseTree.ImportsBlock
 import generators.obj.syntaxParseTree.NamespaceBlock
 import generators.obj.syntaxParseTree.RegionImpl
 
@@ -27,6 +29,7 @@ class CppEnumGenerator(
     override fun invoke(files: List<FileData>, desc: ConstantsEnum) {
         val headerFile = files.find { it is CppHeaderFile }
             ?: throw java.lang.IllegalStateException("Can't find Header file for C++")
+        val imports = headerFile.findOrCreateSub(ImportsBlock::class.java)
 
         val namespace = headerFile.addSub(NamespaceBlock(desc.getParentPath()))
         val region = namespace.addSub(RegionImpl(desc.name))
@@ -49,7 +52,7 @@ class CppEnumGenerator(
                         autoIncrement(it)
                         val rValue = prepareRightValueUseCase.toRightValue(
                             dataField = it,
-                            fileData = headerFile
+                            importsBlock = imports
                         )
                         addEnumLeaf("").apply {
                             addVarName(it.name)

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

@@ -1,10 +1,12 @@
 package generators.cpp
 
 import ce.defs.DataType
+import generators.obj.syntaxParseTree.ImportsBlock
 
 class GetArrayDataTypeUseCase {
-    fun getArrayType(type: DataType): String =
-        when (type) {
+    fun getArrayType(type: DataType, importsBlock: ImportsBlock): String {
+        importsBlock.addInclude("<vector>")
+        return when (type) {
             DataType.int8 -> "std::vector<int8_t>"
             DataType.uint8 -> "std::vector<uint8_t>"
             DataType.int16 -> "std::vector<int16_t>"
@@ -20,4 +22,5 @@ class GetArrayDataTypeUseCase {
             is DataType.custom -> "std::vector<${type.block.name}>"
             else -> "ktQQTP_array_$type"
         }
+    }
 }

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

@@ -1,24 +1,51 @@
 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,
+    fun typeTo(importsBlock: ImportsBlock,
                type: DataType
     ) : String {
         when (type) {
             is DataType.custom ->
-                file.findOrCreateSub(ImportsBlock::class.java)
-                    .addInclude("${type.block.getParentPath()}.${type.block.name}");
+                importsBlock.addInclude("${type.block.getParentPath()}.${type.block.name}");
             else -> {}
         }
+        when (type) {
+            DataType.int8,
+            DataType.int16,
+            DataType.int32,
+            DataType.int64,
+            DataType.uint8,
+            DataType.uint16,
+            DataType.uint32,
+            DataType.uint64,
+            DataType.int8Nullable,
+            DataType.int16Nullable,
+            DataType.int32Nullable,
+            DataType.int64Nullable,
+            DataType.uint8Nullable,
+            DataType.uint16Nullable,
+            DataType.uint32Nullable,
+            DataType.uint64Nullable -> {
+                importsBlock.addInclude("<cstdint>")
+            }
+            DataType.string, DataType.stringNullable -> {
+                importsBlock.addInclude("<string>")
+            }
+            is DataType.array -> {
+                importsBlock.addInclude("<vector>")
+            }
+            else -> {}
+        }
+        if (type.canBeNull) {
+            importsBlock.addInclude("<optional>")
+        }
         val baseType = when (type) {
             DataType.VOID -> "void"
             DataType.int8, DataType.int8Nullable -> "int8_t"
@@ -34,7 +61,7 @@ class GetTypeNameUseCase(
             DataType.bool, DataType.boolNullable -> "bool"
 
             DataType.string, DataType.stringNullable -> "std::string"
-            is DataType.array -> arrayDataType.getArrayType(type.elementDataType)
+            is DataType.array -> arrayDataType.getArrayType(type.elementDataType, importsBlock)
             is DataType.userClass -> type.path
             is DataType.custom -> type.block.name
             is DataType.userClassTest2 -> type.node.getPath()

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

@@ -10,21 +10,19 @@ 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
+import generators.obj.syntaxParseTree.ImportsBlock
 
 class PrepareRightValueUseCase(
     private val getTypeNameUseCase: GetTypeNameUseCase
 ) {
-    fun toRightValue(dataField: DataField, fileData: FileData): RValue =
+    fun toRightValue(dataField: DataField, importsBlock: ImportsBlock): RValue =
         toRightValue(
             type = dataField.getType(),
             value = dataField.getValue(),
-            fileData = fileData
+            importsBlock = importsBlock,
         )
 
-    fun toRightValue(type: DataType, value: DataValue, fileData: FileData): RValue =
+    fun toRightValue(type: DataType, value: DataValue, importsBlock: ImportsBlock): RValue =
         when (type) {
             DataType.VOID -> RValue(name = "void")
             DataType.int8, DataType.int16, DataType.int32, DataType.int64,
@@ -50,7 +48,7 @@ class PrepareRightValueUseCase(
                 } else {
                     val valueComplexItem = value.subs.first()
                     if (valueComplexItem is NewInstance) {
-                        prepareConstructor(valueComplexItem, fileData)
+                        prepareConstructor(valueComplexItem, importsBlock)
                     } else {
                         RValue(name = "QQVAL_complex???")
                     }
@@ -61,12 +59,12 @@ class PrepareRightValueUseCase(
             else -> RValue(name = "QQVAL_$type")
         }
 
-    fun prepareConstructor(item: NewInstance, fileData: FileData): RValue {
+    fun prepareConstructor(item: NewInstance, importsBlock: ImportsBlock): RValue {
         val result = RValue()
         result.addSub(
             Constructor(
                 name = getTypeNameUseCase.typeTo(
-                    file = fileData,
+                    importsBlock = importsBlock,
                     type = item.getType()
                 )
             ).apply {
@@ -84,7 +82,7 @@ class PrepareRightValueUseCase(
                             toRightValue(
                                 type = input.getType(),
                                 value = input.getValue(),
-                                fileData = fileData
+                                importsBlock = importsBlock
                             )
                         )
                     }

cgen-lib/src/test/java/generators/cpp/GetArrayDataTypeUseCaseTest.kt

@@ -1,75 +1,92 @@
 package generators.cpp
 
 import ce.defs.DataType
+import generators.obj.syntaxParseTree.ImportsBlock
+import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 
 class GetArrayDataTypeUseCaseTest {
     private val useCase = GetArrayDataTypeUseCase()
+    private val importsBlock = ImportsBlock()
+
+    @BeforeEach
+    fun setup() {
+        importsBlock.subs.clear()
+    }
+
     @Test
     fun getArrayTypeReturnsByteArrayForInt8() {
-        val result = useCase.getArrayType(DataType.int8)
+        val result = useCase.getArrayType(DataType.int8, importsBlock)
         assertEquals("std::vector<int8_t>", result)
     }
 
     @Test
     fun getArrayTypeReturnsByteArrayForUint8() {
-        val result = useCase.getArrayType(DataType.uint8)
+        val result = useCase.getArrayType(DataType.uint8, importsBlock)
         assertEquals("std::vector<uint8_t>", result)
     }
 
     @Test
     fun getArrayTypeReturnsShortArrayForInt16() {
-        val result = useCase.getArrayType(DataType.int16)
+        val result = useCase.getArrayType(DataType.int16, importsBlock)
         assertEquals("std::vector<int16_t>", result)
     }
 
     @Test
     fun getArrayTypeReturnsIntArrayForInt32() {
-        val result = useCase.getArrayType(DataType.int32)
+        val result = useCase.getArrayType(DataType.int32, importsBlock)
         assertEquals("std::vector<int32_t>", result)
     }
 
     @Test
     fun getArrayTypeReturnsLongArrayForInt64() {
-        val result = useCase.getArrayType(DataType.int64)
+        val result = useCase.getArrayType(DataType.int64, importsBlock)
         assertEquals("std::vector<int64_t>", result)
     }
 
     @Test
     fun getArrayTypeReturnsShortArrayForUint16() {
-        val result = useCase.getArrayType(DataType.uint16)
+        val result = useCase.getArrayType(DataType.uint16, importsBlock)
         assertEquals("std::vector<uint16_t>", result)
     }
 
     @Test
     fun getArrayTypeReturnsIntArrayForUint32() {
-        val result = useCase.getArrayType(DataType.uint32)
+        val result = useCase.getArrayType(DataType.uint32, importsBlock)
         assertEquals("std::vector<uint32_t>", result)
     }
 
     @Test
     fun getArrayTypeReturnsFloatArrayForFloat32() {
-        val result = useCase.getArrayType(DataType.float32)
+        val result = useCase.getArrayType(DataType.float32, importsBlock)
         assertEquals("std::vector<float>", result)
     }
 
     @Test
     fun getArrayTypeReturnsDoubleArrayForFloat64() {
-        val result = useCase.getArrayType(DataType.float64)
+        val result = useCase.getArrayType(DataType.float64, importsBlock)
         assertEquals("std::vector<double>", result)
     }
 
     @Test
     fun getArrayTypeReturnsStringArrayForStringType() {
-        val result = useCase.getArrayType(DataType.string)
+        val result = useCase.getArrayType(DataType.string, importsBlock)
         assertEquals("std::vector<std::string>", result)
     }
 
     @Test
     fun getArrayTypeReturnsUserClassPathForUserClassType() {
         val userClassType = DataType.userClass("MyClass")
-        val result = useCase.getArrayType(userClassType)
+        val result = useCase.getArrayType(userClassType, importsBlock)
         assertEquals("std::vector<MyClass>", result)
     }
+
+    @Test
+    fun getArrayTypeAddsVectorToImports() {
+        val result = useCase.getArrayType(DataType.float64, importsBlock)
+        Assertions.assertEquals(1, importsBlock.subs.size)
+        assertEquals("<vector>", importsBlock.subs[0].name)
+    }
 }