101 строка
2,1 КиБ
Go
101 строка
2,1 КиБ
Go
package service
|
|
|
|
import (
|
|
"go/ast"
|
|
"strings"
|
|
)
|
|
|
|
type abstractClass struct {
|
|
name string
|
|
Interface *ast.InterfaceType
|
|
}
|
|
|
|
func NewAbstractClass(name string) *abstractClass {
|
|
return &abstractClass{name: name}
|
|
}
|
|
|
|
func (c *abstractClass) Name() string {
|
|
return c.name
|
|
}
|
|
|
|
func (c *abstractClass) String() (code string) {
|
|
code += c.abstractClassDefinitionToString()
|
|
return
|
|
}
|
|
func (c *abstractClass) MethodsString() (code string) {
|
|
return
|
|
}
|
|
|
|
func (c *abstractClass) abstractClassDefinitionToString() (code string) {
|
|
code = "class " + c.name + " {\n"
|
|
code += "public:\n"
|
|
|
|
code += c.methodDeclarationsToString()
|
|
code += "\n"
|
|
|
|
code += "};\n"
|
|
return
|
|
}
|
|
func (c *abstractClass) methodDeclarationsToString() (code string) {
|
|
for _, f := range c.Interface.Methods.List {
|
|
code += c.fieldDeclarationToString(f)
|
|
}
|
|
code += "\n"
|
|
return
|
|
}
|
|
func (c *abstractClass) fieldDeclarationToString(f *ast.Field) (code string) {
|
|
code += " virtual "
|
|
switch s := f.Type.(type) {
|
|
case *ast.FuncType:
|
|
code += handleFuncDeclType(s)
|
|
code += " "
|
|
code += handleIdentExpr(f.Names[0])
|
|
code += "("
|
|
code += handleAbstractFuncDeclParams(s)
|
|
code += ") = 0;"
|
|
}
|
|
|
|
return
|
|
}
|
|
func handleAbstractFuncDeclParams(t *ast.FuncType) (code string) {
|
|
if t.Params == nil || t.Params.List == nil {
|
|
return
|
|
}
|
|
values := make([]string, 0)
|
|
for _, field := range t.Params.List {
|
|
t := ""
|
|
switch ft := field.Type.(type) {
|
|
case *ast.Ident:
|
|
t = handleIdentExpr(ft)
|
|
case *ast.StarExpr:
|
|
t = handleStarExpr(ft)
|
|
t += "*"
|
|
}
|
|
values = append(values, t)
|
|
}
|
|
code += strings.Join(values, ",")
|
|
return
|
|
}
|
|
|
|
func (c *abstractClass) AddMethod(m *ast.FuncDecl) {}
|
|
|
|
func handleClassAbstract(name string, it *ast.InterfaceType) string {
|
|
addAbstractClassFromStructType(name, it)
|
|
return ""
|
|
}
|
|
func addAbstractClassFromStructType(name string, it *ast.InterfaceType) Class {
|
|
c := createAbstractClass(name)
|
|
c.Interface = it
|
|
return c
|
|
}
|
|
func createAbstractClass(className string) *abstractClass {
|
|
c := NewAbstractClass(className)
|
|
addAbstractClassDeclaration(c)
|
|
return c
|
|
}
|
|
func addAbstractClassDeclaration(c Class) {
|
|
dlock.Lock()
|
|
defer dlock.Unlock()
|
|
|
|
classDeclarations = append(classDeclarations, c)
|
|
}
|