json data to struct code

main.go

package main

import (
    "bytes"
	"crypto/md5"
	"encoding/json"
	"flag"
	"fmt"
	"io"
)

const APP_VERSION = "0.1"

type result struct {
	Data map[string]string
}

// The flag package provides a default help printer via -h switch
var versionFlag *bool = flag.Bool("v", false, "Print the version number.")
var jsonFlag *string = flag.String("j", "[1,2,3]", "Print the version number.")

var jsonStr result //make(map[string]string)

func main() {
	flag.Parse() // Scan the arguments list
	jsonStr = result{Data: make(map[string]string)}

	if *versionFlag {
		fmt.Println("Version:", APP_VERSION)
		fmt.Printf("%s\n", *jsonFlag)
	}
	b := []byte(*jsonFlag)
	var f interface{}
	json.Unmarshal(b, &f)
	fmt.Println("parsing...")

	switch ff := f.(type) {
	case []interface{}:
		parseArray("Array", ff)
	case map[string]interface{}:
		parse("Data", ff)
	default:
		fmt.Println("error")
	}
	fmt.Println("---- result ----")
	jsonStr.Print()
}

func parseArray(name string, t []interface{}) (s string) {
	if len(t) == 0 {
		return "[]interface{}"
	}
	switch vv := t[0].(type) {
	case bool:
		return fmt.Sprintf("[]%T", vv)
	case string:
		return fmt.Sprintf("[]%T", vv)
	case float64:
		return fmt.Sprintf("[]%T", vv)
	case map[string]interface{}:
		parse(name, vv)
		return fmt.Sprintf("[]%s", name)
	case []interface{}:
		return fmt.Sprintf("[]%s", parseArray(name, vv))
	default:
	}
	return "[]interface{}"
}

func parse(t string, m map[string]interface{}) {
	var buffer bytes.Buffer
	buffer.WriteString(fmt.Sprintf("type %s struct {\n", t))
	//fmt.Println("type ", t, " struct {")
	for k, v := range m {
		switch vv := v.(type) {
		case bool:
			//fmt.Println(k, "\t", vv)
			buffer.WriteString(fmt.Sprintf("\t%s\t%T\n", k, vv))
		case string:
			//fmt.Println(k, "\t", vv)
			buffer.WriteString(fmt.Sprintf("\t%s\t%T\n", k, vv))
		case float64:
			//fmt.Println(k, "\t", vv)
			buffer.WriteString(fmt.Sprintf("\t%s\t%T\n", k, vv))
		case map[string]interface{}:
			//fmt.Println(k, "is map", vv)
			buffer.WriteString(fmt.Sprintf("\t%s\t%s\n", k, k))
			parse(k, vv)
		case []interface{}:
			//fmt.Println(k, "is an array:")
			buffer.WriteString(fmt.Sprintf("\t%s\t%s\n", k, parseArray(k, vv)))
		default:
			//fmt.Println("unexpected type %T", vv)
		}
	}
	buffer.WriteString("}")
	jsonStr.Insert(buffer.String())
}

func (f *result) Insert(s string) {
	h := md5.New()
	io.WriteString(h, s)
	f.Data[fmt.Sprintf("%x", h.Sum(nil))] = s
}

func (f result) Print() {
	for _, v := range f.Data {
		defer fmt.Println(v)
	}
}