Golang Decoder.More方法代碼示例

func parseSif(cxDecoder *json.Decoder, w *csv.Writer) {

	// Edge slice used for later mapping
	var edges []cx.Edge

	// Node ID to node name map
	nodeMap := make(map[int64]string)

	for {
		_, err := cxDecoder.Token()

		if err == io.EOF {
			break
		} else if err != nil {
			fmt.Println("Error: ", err)
			return
		}

		for cxDecoder.More() {
			token, err := cxDecoder.Token()
			if err != nil {
				fmt.Println(err)
			}

			if token == "nodes" {
				processNode(cxDecoder, nodeMap)
			} else if token == "edges" {
				processEdge(cxDecoder, &edges)
			}
		}
	}

	writeSif(nodeMap, edges, *w)
}

func toList(cxDecoder *json.Decoder, w io.Writer) {

	// Node ID to node name map
	nodeMap := make(map[string]int64)

	for {
		_, err := cxDecoder.Token()

		if err == io.EOF {
			break
		} else if err != nil {
			fmt.Println("Error: ", err)
			return
		}

		for cxDecoder.More() {
			token, err := cxDecoder.Token()
			if err != nil {
				fmt.Println(err)
			}

			if token == "nodes" {
				processNode(cxDecoder, nodeMap)
			}
		}
	}

	err := json.NewEncoder(w).Encode(nodeMap)
	if err != nil {
		panic("parse err")
	}
}

func findFeatureArray(dec *json.Decoder) error {
	for {
		t, err := dec.Token()
		if err == io.EOF {
			break
		}
		if err != nil {
			return err
		}
		if s, ok := t.(string); ok && s == "features" && dec.More() {
			// we found the features element
			d, err := dec.Token()
			if err != nil {
				return err
			}
			if delim, ok := d.(json.Delim); ok {
				if delim.String() == "[" {
					// we have our start of the array
					break
				} else {
					// A different kind of delimiter
					return fmt.Errorf("Expected features to be an array.")
				}
			}
		}
	}

	if !dec.More() {
		return fmt.Errorf("Cannot find any features.")
	}
	return nil
}

// parse one level of the json translation file, this func will also parse sublevels by calling
func readLevel(jspath string, dec *json.Decoder, tr map[string]string) {
	if jspath == "" {
		t, err := dec.Token()
		if err != nil {
			log.Fatal("translate error 1: ", err)
		}
		if fmt.Sprintf("%T:%v", t, t) != "json.Delim:{" {
			log.Fatal("translate error 1.1: bad translaton file format")
		}
		//fmt.Printf("%s> %T:%v\n", jspath, t, t)
	}

	for dec.More() {
		t1, err1 := dec.Token()
		t2, err2 := dec.Token()

		if err1 != nil {
			log.Fatal("translate error 2: ", err1)
		}

		if err2 != nil {
			log.Fatal("translate error 3: ", err2)
		}

		//fmt.Printf("%s: %T:%v => %T:%v\n", jspath, t1, t1, t2, t2)

		var newpath string
		if jspath == "" {
			newpath = fmt.Sprintf("%v", t1)
		} else {
			newpath = fmt.Sprintf("%s.%v", jspath, t1)
		}
		if fmt.Sprintf("%T:%v", t2, t2) == "json.Delim:{" {
			readLevel(newpath, dec, tr)
		} else {
			tr[newpath] = fmt.Sprintf("%v", t2)
			//fmt.Printf("%s => %v\n", newpath, t2)
		}
	}

	t, err := dec.Token()
	if err != nil {
		log.Fatal("translate error 3=4: ", err)
	}
	if fmt.Sprintf("%T:%v", t, t) != "json.Delim:}" {
		log.Fatal("translate error 4.1: bad translaton file format")
	}
	//fmt.Printf("%s< %T:%v\n", jspath, t, t)

}

func processEdge(decoder *json.Decoder, edges *[]cx.Edge) {
	token, err := decoder.Token()
	if err != nil || token != arrayStart {
		return
	}

	var entry cx.Edge
	for decoder.More() {
		err := decoder.Decode(&entry)
		if err != nil {
			return
		}
		*edges = append(*edges, entry)
	}
}

func (m *omap) unmarshalJSON(dec *json.Decoder) error {
	for dec.More() {
		t, err := dec.Token()
		if err != nil {
			return err
		}

		key, isKey := t.(string)
		if !isKey {
			return fmt.Errorf("%t %s is not string(expected key)", t, t)
		}

		val, err := getVal(dec)
		if err != nil {
			return err
		}
		m.Set(key, val)
	}
	return nil
}

func processNode(decoder *json.Decoder, nodes map[int64]string) {
	token, err := decoder.Token()
	if err != nil || token != arrayStart {
		return
	}

	var entry cx.Node
	for decoder.More() {
		err := decoder.Decode(&entry)
		if err != nil {
			return
		}

		if entry.N == "" {
			nodes[entry.ID] = strconv.FormatInt(entry.ID, 10)
		} else {
			nodes[entry.ID] = entry.N
		}
	}

}

func processNode(decoder *json.Decoder, nodes map[string]int64) {
	_, err := decoder.Token()
	if err != nil {
		return
	}

	var entry cx.Node

	for decoder.More() {
		err := decoder.Decode(&entry)
		if err != nil {
			return
		}

		if entry.N == "" {
			nodes[strconv.FormatInt(entry.ID, 10)] = entry.ID
		} else {
			nodes[entry.N] = entry.ID
		}
	}
}

func run(cxDecoder *json.Decoder, w io.Writer) {

	// Initialize handlers
	handlers := initHandlers()

	// Network Object
	networkAttr := make(map[string]interface{})

	// Elements
	var nodes []cyjs.CyJSNode
	var edges []cyjs.CyJSEdge
	layout := make(map[string]interface{})
	vps := make(map[string]interface{})

	elements := cyjs.Elements{Nodes: nodes, Edges: edges}

	// Temp storage for attributes
	nodeAttrs := make(map[string]interface{})
	edgeAttrs := make(map[string]interface{})

	cxData := make(map[string]interface{})
	// Basic Cytoscape.js object
	cyjsNetwork := cyjs.CyJS{Data: networkAttr, Elements: elements,
		CxData: cxData}

	for {
		_, err := cxDecoder.Token()

		if err == io.EOF {
			break
		} else if err != nil {
			log.Println(err)
			return
		}

		// Decode entry one-by-one.
		for cxDecoder.More() {
			var entry map[string]interface{}
			err := cxDecoder.Decode(&entry)
			if err != nil {
				log.Fatal(err)
			}

			parseCxEntry(handlers, entry, &cyjsNetwork, &nodeAttrs,
				&edgeAttrs, &layout, &vps)
		}
	}

	assignNodeAttr(cyjsNetwork.Elements.Nodes, nodeAttrs, layout)
	assignEdgeAttr(cyjsNetwork.Elements.Edges, edgeAttrs)

	// Add style to net (if style data is available...)
	if vps != nil && reflect.ValueOf(vps).IsNil() == false {
		if vps["style"] != nil {
			cyjsNetwork.Style = vps["style"].([]cyjs.SelectorEntry)
		}
	}

	jsonString, err := json.Marshal(cyjsNetwork)

	if err != nil {
		fmt.Println("ERR: ", err)
	} else {
		//		fmt.Println(string(jsonString))
		w.Write(jsonString)
	}
	//debug()
}

// LoadJSON loads data from a JSON file in the database table.
//
// If src != nil, LoadJSON loads the source from src and the filename is only used
// when recording file information. The type of the argument for the src parameter
// must be []byte, or io.Reader. If src == nil, LoadJSON loads the file
// specified by filename.
func (cx *DBContext) LoadJSON(src interface{}, filename, table string) (err error) {
	var dec *json.Decoder

	if src != nil {
		switch s := src.(type) {
		case []byte:
			dec = json.NewDecoder(bytes.NewReader(s))
		case io.Reader:
			dec = json.NewDecoder(s)
		default:
			return fmt.Errorf("invalid source")
		}
	} else {
		f, err := os.Open(filename)
		if err != nil {
			return err
		}
		defer func() {
			if err1 := f.Close(); err == nil {
				err = err1
			}
		}()

		dec = json.NewDecoder(f)
	}

	// The first row must have the name of the columns.
	firstRecord := make([]string, 0)
	if err = dec.Decode(&firstRecord); err != nil {
		return err
	}

	tx, err := cx.DB.Begin()
	if err != nil {
		return err
	}
	defer func() {
		if err != nil {
			err1 := tx.Rollback()
			if err1 != nil && datautil.VERBOSE {
				log.WithFields(log.Fields{
					"file":  filename,
					"table": table,
				}).Warn(err1)
			}
		}
	}()

	insertCode := fmt.Sprintf("INSERT INTO %s (%s) VALUES(%s)",
		table,
		strings.Join(firstRecord, ", "),
		cx.bindChars(len(firstRecord)),
	)
	insert, err := tx.Prepare(insertCode)
	if err != nil {
		return fmt.Errorf("SQL code: %q\n%s", insertCode, err)
	}

	list := make([]interface{}, 0)

	for line := 2; dec.More(); line++ {
		if err = dec.Decode(&list); err != nil {
			return fmt.Errorf("%q line %d: %s", filename, line, err)
		}

		_, err = tx.Stmt(insert).Exec(list...)
		if err != nil {
			return fmt.Errorf("code: %q vars: %v => %s", insertCode, list, err)
		}
	}

	if err = insert.Close(); err != nil && datautil.VERBOSE {
		log.WithFields(log.Fields{
			"file":  filename,
			"table": table,
		}).Warn(err)
	}

	if err = tx.Commit(); err != nil {
		return err
	}
	if datautil.VERBOSE {
		log.WithFields(log.Fields{
			"file":  packer.RelativeDir(filename),
			"db":    cx.Conn.GetDBName(),
			"table": table,
		}).Info("Load JSON file")
	}
	return nil
}