func findClass(typ types.Type) (class Class) {
named, ok := typ.(*types.Named)
if !ok {
return Uninterested
}
var struc *types.Struct
if struc, ok = named.Underlying().(*types.Struct); !ok {
return Uninterested
}
for i := 0; i < struc.NumFields(); i++ {
f := struc.Field(i)
switch {
case !f.Anonymous():
continue
case f.Name() == "Base":
return ModelStruct
case f.Name() == "List":
return ListStruct
}
}
return Uninterested
}
func (c *funcContext) loadStruct(array, target string, s *types.Struct) string {
view := c.newVariable("_view")
code := fmt.Sprintf("%s = new DataView(%s.buffer, %s.byteOffset)", view, array, array)
var fields []*types.Var
var collectFields func(s *types.Struct, path string)
collectFields = func(s *types.Struct, path string) {
for i := 0; i < s.NumFields(); i++ {
field := s.Field(i)
if fs, isStruct := field.Type().Underlying().(*types.Struct); isStruct {
collectFields(fs, path+"."+fieldName(s, i))
continue
}
fields = append(fields, types.NewVar(0, nil, path+"."+fieldName(s, i), field.Type()))
}
}
collectFields(s, target)
offsets := sizes32.Offsetsof(fields)
for i, field := range fields {
switch t := field.Type().Underlying().(type) {
case *types.Basic:
if isNumeric(t) {
if is64Bit(t) {
code += fmt.Sprintf(", %s = new %s(%s.getUint32(%d, true), %s.getUint32(%d, true))", field.Name(), c.typeName(field.Type()), view, offsets[i]+4, view, offsets[i])
break
}
code += fmt.Sprintf(", %s = %s.get%s(%d, true)", field.Name(), view, toJavaScriptType(t), offsets[i])
}
case *types.Array:
code += fmt.Sprintf(`, %s = new ($nativeArray(%s))(%s.buffer, $min(%s.byteOffset + %d, %s.buffer.byteLength))`, field.Name(), typeKind(t.Elem()), array, array, offsets[i], array)
}
}
return code
}
func fieldName(t *types.Struct, i int) string {
name := t.Field(i).Name()
if name == "_" || reservedKeywords[name] {
return fmt.Sprintf("%s$%d", name, i)
}
return name
}
// matchStructArgType reports whether all the elements of the struct match the expected
// type. For instance, with "%d" all the elements must be printable with the "%d" format.
func (f *File) matchStructArgType(t printfArgType, typ *types.Struct, arg ast.Expr, inProgress map[types.Type]bool) bool {
for i := 0; i < typ.NumFields(); i++ {
if !f.matchArgTypeInternal(t, typ.Field(i).Type(), arg, inProgress) {
return false
}
}
return true
}
func exportedFields(T *types.Struct) []*types.Var {
var fields []*types.Var
for i := 0; i < T.NumFields(); i++ {
f := T.Field(i)
if !f.Exported() {
continue
}
fields = append(fields, f)
}
return fields
}
func optimalSize(str *types.Struct, sizes *gcSizes) int64 {
nf := str.NumFields()
fields := make([]*types.Var, nf)
alignofs := make([]int64, nf)
sizeofs := make([]int64, nf)
for i := 0; i < nf; i++ {
fields[i] = str.Field(i)
ft := fields[i].Type()
alignofs[i] = sizes.Alignof(ft)
sizeofs[i] = sizes.Sizeof(ft)
}
sort.Sort(&byAlignAndSize{fields, alignofs, sizeofs})
return sizes.Sizeof(types.NewStruct(fields, nil))
}
func (p *exporter) fieldList(t *types.Struct) {
if trace && t.NumFields() > 0 {
p.tracef("fields {>\n")
defer p.tracef("<\n} ")
}
p.int(t.NumFields())
for i := 0; i < t.NumFields(); i++ {
if trace && i > 0 {
p.tracef("\n")
}
p.field(t.Field(i))
p.string(t.Tag(i))
}
}
func (c *converter) convertStruct(v *gotypes.Struct) *types.Struct {
if v == nil {
return nil
}
if v, ok := c.converted[v]; ok {
return v.(*types.Struct)
}
fields := make([]*types.Var, 0, v.NumFields())
tags := make([]string, 0, v.NumFields())
for i := 0; i < v.NumFields(); i++ {
fields = append(fields, c.convertVar(v.Field(i)))
tags = append(tags, v.Tag(i))
}
ret := types.NewStruct(fields, tags)
c.converted[v] = ret
return ret
}
func (w *Walker) emitStructType(name string, typ *types.Struct) {
typeStruct := fmt.Sprintf("type %s struct", name)
w.emitf(typeStruct)
defer w.pushScope(typeStruct)()
for i := 0; i < typ.NumFields(); i++ {
f := typ.Field(i)
if !f.Exported() {
continue
}
typ := f.Type()
if f.Anonymous() {
w.emitf("embedded %s", w.typeString(typ))
continue
}
w.emitf("%s %s", f.Name(), w.typeString(typ))
}
}
// embeddedObjcTypes returns the possible empty list of Objc types embedded
// in the given struct type.
func embeddedObjcTypes(t *types.Struct) []string {
typeSet := make(map[string]struct{})
var typs []string
for i := 0; i < t.NumFields(); i++ {
f := t.Field(i)
if !f.Exported() {
continue
}
if ft := f.Type(); isObjcType(ft) {
name := ft.(*types.Named).Obj().Name()
if _, exists := typeSet[name]; !exists {
typeSet[name] = struct{}{}
typs = append(typs, name)
}
}
}
return typs
}
// embeddedJavaClasses returns the possible empty list of Java types embedded
// in the given struct type.
func embeddedJavaClasses(t *types.Struct) []string {
clsSet := make(map[string]struct{})
var classes []string
for i := 0; i < t.NumFields(); i++ {
f := t.Field(i)
if !f.Exported() {
continue
}
if t := f.Type(); isJavaType(t) {
cls := classNameFor(t)
if _, exists := clsSet[cls]; !exists {
clsSet[cls] = struct{}{}
classes = append(classes, cls)
}
}
}
return classes
}
func findClass(typ types.Type) (class Class) {
named, ok := typ.(*types.Named)
if !ok {
return Uninterested
}
name := named.Obj().Name()
switch name {
case "List", "Base":
return Uninterested
}
for i := 0; i < named.NumMethods(); i++ {
m := named.Method(i)
if m.Name() == "Op" {
return OperationStruct
}
}
var struc *types.Struct
if struc, ok = named.Underlying().(*types.Struct); !ok {
return Uninterested
}
for i := 0; i < struc.NumFields(); i++ {
f := struc.Field(i)
switch {
case !f.Anonymous():
continue
case f.Name() == "Base":
return ModelStruct
case f.Name() == "List":
return ListStruct
}
}
return Uninterested
}
func collectFields(fields map[string]string, struc *types.Struct) {
// TODO:
for i := 0; i < struc.NumFields(); i++ {
f, tag := struc.Field(i), struc.Tag(i)
switch {
case f.Anonymous():
if named, ok := f.Type().(*types.Named); ok {
if struc_, ok := named.Underlying().(*types.Struct); ok {
collectFields(fields, struc_)
}
}
case strings.Contains(tag, `pretty:""`):
fields[f.Name()] = inflect.Underscore(f.Name())
}
}
}
func collectFields(struc *types.Struct) []string {
result := []string{}
for i := 0; i < struc.NumFields(); i++ {
f, tag := struc.Field(i), struc.Tag(i)
switch {
case f.Anonymous():
if named, ok := f.Type().(*types.Named); ok {
if struc_, ok := named.Underlying().(*types.Struct); ok {
result = append(result, collectFields(struc_)...)
}
}
case strings.Contains(tag, `pretty:""`):
result = append(result, f.Name())
}
}
return result
}