Create the stub impls

Author: robertgoss

Source/buildimplementationrust.go

@@ -47,15 +47,18 @@ func BuildImplementationRust(component ComponentDefinition, outputFolder string,
 	forceRebuild := true
 	LibraryName := component.LibraryName
 	BaseName := component.BaseName
+	modfiles := make([]string, 0)
 	indentString := getIndentationString(implementation.Indentation)
 
 	stubIdentifier := ""
 	if len(implementation.StubIdentifier) > 0 {
 		stubIdentifier = "_" + strings.ToLower(implementation.StubIdentifier)
 	}
 
-	IntfFileName := BaseName + "_interfaces.rs"
+	InterfaceMod := BaseName + "_interfaces"
+	IntfFileName := InterfaceMod + ".rs"
 	IntfFilePath := path.Join(outputFolder, IntfFileName)
+	modfiles = append(modfiles, IntfFilePath)
 	log.Printf("Creating \"%s\"", IntfFilePath)
 	IntfRSFile, err := CreateLanguageFile(IntfFilePath, indentString)
 	if err != nil {
@@ -68,12 +71,13 @@ func BuildImplementationRust(component ComponentDefinition, outputFolder string,
 	if err != nil {
 		return err
 	}
-	err = buildRustInterfaces(component, IntfRSFile, implementation.ClassIdentifier)
+	err = buildRustInterfaces(component, IntfRSFile)
 	if err != nil {
 		return err
 	}
 
 	IntfWrapperStubName := path.Join(stubOutputFolder, BaseName+stubIdentifier+".rs")
+	modfiles = append(modfiles, IntfWrapperStubName)
 	if forceRebuild || !FileExists(IntfWrapperStubName) {
 		log.Printf("Creating \"%s\"", IntfWrapperStubName)
 		stubfile, err := CreateLanguageFile(IntfWrapperStubName, indentString)
@@ -83,19 +87,62 @@ func BuildImplementationRust(component ComponentDefinition, outputFolder string,
 		stubfile.WriteCLicenseHeader(component,
 			fmt.Sprintf("This is an autogenerated Rust implementation file in order to allow easy\ndevelopment of %s. It needs to be generated only once.", LibraryName),
 			true)
-		RelInterfaceFile, err := filepath.Rel(stubOutputFolder, IntfFilePath)
 		if err != nil {
 			return err
 		}
-		err = buildRustGlobalStubFile(component, stubfile, implementation.ClassIdentifier, RelInterfaceFile)
+		err = buildRustGlobalStubFile(component, stubfile, InterfaceMod)
 		if err != nil {
 			return err
 		}
 	} else {
 		log.Printf("Omitting recreation of implementation stub \"%s\"", IntfWrapperStubName)
 	}
 
+	for i := 0; i < len(component.Classes); i++ {
+		class := component.Classes[i]
+		StubBase := BaseName + stubIdentifier
+		StubClassName := path.Join(stubOutputFolder, StubBase+"_"+toSnakeCase(class.ClassName)+".rs")
+		modfiles = append(modfiles, StubClassName)
+		if forceRebuild || !FileExists(StubClassName) {
+			log.Printf("Creating \"%s\"", StubClassName)
+			stubfile, err := CreateLanguageFile(StubClassName, indentString)
+			if err != nil {
+				return err
+			}
+			stubfile.WriteCLicenseHeader(component,
+				fmt.Sprintf("This is an autogenerated Rust implementation file in order to allow easy\ndevelopment of %s. It needs to be generated only once.", LibraryName),
+				true)
+			if err != nil {
+				return err
+			}
+			err = buildRustStubFile(component, class, stubfile, InterfaceMod, StubBase)
+			if err != nil {
+				return err
+			}
+		} else {
+			log.Printf("Omitting recreation of implementation stub \"%s\"", StubClassName)
+		}
+	}
+
 	if len(projectOutputFolder) > 0 {
+		IntfWrapperLibName := path.Join(projectOutputFolder, "lib.rs")
+		if forceRebuild || !FileExists(IntfWrapperLibName) {
+			log.Printf("Creating \"%s\"", IntfWrapperLibName)
+			libfile, err := CreateLanguageFile(IntfWrapperLibName, indentString)
+			if err != nil {
+				return err
+			}
+			libfile.WriteCLicenseHeader(component,
+				fmt.Sprintf("This is an autogenerated Rust implementation file in order to allow easy\ndevelopment of %s. It needs to be generated only once.", LibraryName),
+				true)
+			err = buildRustGlobalLibFile(component, libfile, projectOutputFolder, modfiles)
+			if err != nil {
+				return err
+			}
+		} else {
+			log.Printf("Omitting recreation of lib \"%s\"", IntfWrapperLibName)
+		}
+
 		CargoFileName := path.Join(projectOutputFolder, "Cargo.toml")
 		if forceRebuild || !FileExists(CargoFileName) {
 			log.Printf("Creating Cargo file \"%s\" for Rust Implementation", CargoFileName)
@@ -106,7 +153,7 @@ func BuildImplementationRust(component ComponentDefinition, outputFolder string,
 			CargoFile.WriteTomlLicenseHeader(component,
 				fmt.Sprintf("This is an autogenerated Cargo file for the development of %s.", LibraryName),
 				true)
-			LibPath, err := filepath.Rel(projectOutputFolder, IntfWrapperStubName)
+			LibPath, err := filepath.Rel(projectOutputFolder, IntfWrapperLibName)
 			if err != nil {
 				return err
 			}
@@ -119,16 +166,24 @@ func BuildImplementationRust(component ComponentDefinition, outputFolder string,
 	return nil
 }
 
-func buildRustGlobalStubFile(component ComponentDefinition, w LanguageWriter, ClassIdentifier string, RelInterfaceFile string) error {
+func buildRustGlobalLibFile(component ComponentDefinition, w LanguageWriter, basedir string, modfiles []string) error {
 	w.Writeln("")
 	// Get all modules
-	w.Writeln("#[path = \"%s\"]", strings.ReplaceAll(RelInterfaceFile, "\\", "/"))
-	IntfName := strings.TrimSuffix(filepath.Base(RelInterfaceFile), ".rs")
-	w.Writeln("mod %s;", IntfName)
+	for i := 0; i < len(modfiles); i++ {
+		modfile := modfiles[i]
+		relfile, err := filepath.Rel(basedir, modfile)
+		if err != nil {
+			return err
+		}
+		w.Writeln("#[path = \"%s\"]", strings.ReplaceAll(relfile, "\\", "/"))
+		IntfName := strings.TrimSuffix(filepath.Base(relfile), ".rs")
+		w.Writeln("mod %s;", IntfName)
+		w.Writeln("")
+	}
 	return nil
 }
 
-func buildRustInterfaces(component ComponentDefinition, w LanguageWriter, ClassIdentifier string) error {
+func buildRustInterfaces(component ComponentDefinition, w LanguageWriter) error {
 	NameSpace := component.NameSpace
 	w.Writeln("/*************************************************************************************************************************")
 	w.Writeln(" Traits defined for %s", NameSpace)
@@ -178,7 +233,7 @@ func writeRustTrait(component ComponentDefinition, class ComponentDefinitionClas
 			parentClassString = fmt.Sprintf(": %s ", class.ParentClass)
 		}
 	}
-	w.Writeln("trait %s %s {", class.ClassName, parentClassString)
+	w.Writeln("pub trait %s %s {", class.ClassName, parentClassString)
 	w.AddIndentationLevel(1)
 	methods := class.Methods
 	if component.isBaseClass(class) {
@@ -194,7 +249,7 @@ func writeRustTrait(component ComponentDefinition, class ComponentDefinitionClas
 	for j := 0; j < len(methods); j++ {
 		method := methods[j]
 		w.Writeln("")
-		err := writeRustTraitFn(method, w, true)
+		err := writeRustTraitFn(method, w, true, false, false)
 		if err != nil {
 			return err
 		}
@@ -206,12 +261,13 @@ func writeRustTrait(component ComponentDefinition, class ComponentDefinitionClas
 	return nil
 }
 
-func writeRustTraitFn(method ComponentDefinitionMethod, w LanguageWriter, hasSelf bool) error {
+func writeRustTraitFn(method ComponentDefinitionMethod, w LanguageWriter, hasSelf bool, hasImpl bool, hasImplParent bool) error {
 	methodName := toSnakeCase(method.MethodName)
 	w.Writeln("// %s", methodName)
 	w.Writeln("//")
 	w.Writeln("// %s", method.MethodDescription)
 	parameterString := ""
+	parameterNames := ""
 	if hasSelf {
 		parameterString += "&mut self"
 	}
@@ -229,35 +285,192 @@ func writeRustTraitFn(method ComponentDefinitionMethod, w LanguageWriter, hasSel
 			} else {
 				parameterString += fmt.Sprintf(", %s : %s", RustParam.ParamName, RustParam.ParamType)
 			}
+			if parameterNames == "" {
+				parameterNames += RustParam.ParamName
+			} else {
+				parameterNames += fmt.Sprintf(", %s", RustParam.ParamName)
+			}
 		} else {
 			returnType = RustParam.ParamType
 		}
 		w.Writeln("// %s", RustParam.ParamComment)
 	}
 	w.Writeln("//")
-	if returnType == "" {
-		w.Writeln("fn %s(%s);", methodName, parameterString)
+	if !hasImpl {
+		if returnType == "" {
+			w.Writeln("fn %s(%s);", methodName, parameterString)
+		} else {
+			w.Writeln("fn %s(%s) -> %s;", methodName, parameterString, returnType)
+		}
 	} else {
-		w.Writeln("fn %s(%s) -> %s;", methodName, parameterString, returnType)
+		if returnType == "" {
+			w.Writeln("fn %s(%s) {", methodName, parameterString)
+		} else {
+			w.Writeln("fn %s(%s) -> %s {", methodName, parameterString, returnType)
+		}
+		w.AddIndentationLevel(1)
+		if !hasImplParent {
+			w.Writeln("unimplemented!();")
+		} else {
+			w.Writeln("self.parent.%s(%s)", methodName, parameterNames)
+		}
+		w.AddIndentationLevel(-1)
+		w.Writeln("}")
 	}
 	return nil
 }
 
 func writeRustGlobalTrait(component ComponentDefinition, w LanguageWriter) error {
 	w.Writeln("// Wrapper trait for global methods")
 	w.Writeln("//")
-	w.Writeln("trait Wrapper {")
+	w.Writeln("pub trait Wrapper {")
+	w.AddIndentationLevel(1)
+	methods := component.Global.Methods
+	for j := 0; j < len(methods); j++ {
+		method := methods[j]
+		w.Writeln("")
+		err := writeRustTraitFn(method, w, false, false, false)
+		if err != nil {
+			return err
+		}
+	}
+	w.ResetIndentationLevel()
+	w.Writeln("}")
+	return nil
+}
+
+func buildRustGlobalStubFile(component ComponentDefinition, w LanguageWriter, InterfaceMod string) error {
+	w.Writeln("")
+	w.Writeln("use %s::*;", InterfaceMod)
+	w.Writeln("")
+	w.Writeln("// Wrapper struct to implement the wrapper trait for global methods")
+	w.Writeln("struct CWrapper;")
+	w.Writeln("")
+	w.Writeln("impl Wrapper for CWrapper {")
+	w.Writeln("")
 	w.AddIndentationLevel(1)
 	methods := component.Global.Methods
 	for j := 0; j < len(methods); j++ {
 		method := methods[j]
 		w.Writeln("")
-		err := writeRustTraitFn(method, w, false)
+		err := writeRustTraitFn(method, w, false, true, false)
 		if err != nil {
 			return err
 		}
 	}
 	w.ResetIndentationLevel()
 	w.Writeln("}")
+	w.Writeln("")
+	return nil
+}
+
+func getParentList(component ComponentDefinition, class ComponentDefinitionClass) ([]string, error) {
+	parents := make([]string, 0)
+	currClass := class
+	for !component.isBaseClass(currClass) {
+		parent := currClass.ParentClass
+		if parent == "" {
+			parent = component.baseClass().ClassName
+		}
+		parents = append(parents, parent)
+		parClass, err := getClass(component, parent)
+		if err != nil {
+			return parents, err
+		}
+		currClass = parClass
+	}
+	return parents, nil
+}
+
+func getClass(component ComponentDefinition, name string) (ComponentDefinitionClass, error) {
+	for i := 0; i < len(component.Classes); i++ {
+		class := component.Classes[i]
+		if class.ClassName == name {
+			return class, nil
+		}
+	}
+	return component.baseClass(), fmt.Errorf("Cannot find class %s", name)
+}
+
+func buildRustStubFile(component ComponentDefinition, class ComponentDefinitionClass, w LanguageWriter, InterfaceMod string, StubBase string) error {
+	Name := class.ClassName
+	parents, err := getParentList(component, class)
+	if err != nil {
+		return err
+	}
+	w.Writeln("")
+	w.Writeln("use %s::*;", InterfaceMod)
+	if len(parents) > 0 {
+		parentName := parents[0]
+		w.Writeln("use %s_%s::C%s;", StubBase, toSnakeCase(parentName), parentName)
+	}
+	w.Writeln("")
+	w.Writeln("// Stub struct to implement the %s trait", Name)
+	if len(parents) == 0 {
+		w.Writeln("pub struct C%s;", Name)
+	} else {
+		w.Writeln("pub struct C%s {", Name)
+		w.AddIndentationLevel(1)
+		w.Writeln("parent : C%s", parents[0])
+		w.ResetIndentationLevel()
+		w.Writeln("}")
+		w.Writeln("")
+		w.Writeln("// Implementation of parent traits via parent")
+		w.Writeln("")
+		for i := 0; i < len(parents); i++ {
+			parent := parents[i]
+			parentClass, err := getClass(component, parent)
+			if err != nil {
+				return err
+			}
+			w.Writeln("impl %s for C%s {", parent, Name)
+			w.AddIndentationLevel(1)
+			methods := parentClass.Methods
+			if component.isBaseClass(parentClass) {
+				methods = append(
+					methods,
+					GetLastErrorMessageMethod(),
+					ClearErrorMessageMethod(),
+					RegisterErrorMessageMethod(),
+					IncRefCountMethod(),
+					DecRefCountMethod())
+			}
+			for j := 0; j < len(methods); j++ {
+				method := methods[j]
+				w.Writeln("")
+				err := writeRustTraitFn(method, w, true, true, true)
+				if err != nil {
+					return err
+				}
+			}
+			w.ResetIndentationLevel()
+			w.Writeln("}")
+		}
+	}
+	w.Writeln("")
+	w.Writeln("impl %s for C%s {", Name, Name)
+	w.Writeln("")
+	w.AddIndentationLevel(1)
+	methods := class.Methods
+	if component.isBaseClass(class) {
+		methods = append(
+			methods,
+			GetLastErrorMessageMethod(),
+			ClearErrorMessageMethod(),
+			RegisterErrorMessageMethod(),
+			IncRefCountMethod(),
+			DecRefCountMethod())
+	}
+	for j := 0; j < len(methods); j++ {
+		method := methods[j]
+		w.Writeln("")
+		err := writeRustTraitFn(method, w, true, true, false)
+		if err != nil {
+			return err
+		}
+	}
+	w.ResetIndentationLevel()
+	w.Writeln("}")
+	w.Writeln("")
 	return nil
 }

Source/languagerust.go

@@ -140,7 +140,7 @@ func writeRustBaseTypeDefinitions(componentdefinition ComponentDefinition, w Lan
 			}
 			w.Writeln("//")
 			funcName := funcinfo.FunctionName
-			w.Writeln("type %s = unsafe extern \"C\" fn(%s);", funcName, parameterString)
+			w.Writeln("pub type %s = unsafe extern \"C\" fn(%s);", funcName, parameterString)
 		}
 	}