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 }
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 decodeArray(dec *json.Decoder) (Array, error) { arr := make(Array, 0) for { tok, err := dec.Token() if err != nil { return arr, err } switch token := tok.(type) { case json.Delim: switch rune(token) { case ']': return arr, nil case '{': obj, err := decodeObject(dec) if err != nil { return arr, err } arr = append(arr, obj) case '[': return decodeArray(dec) default: return nil, Errorf("Unexpected token %s", token) } } } }
func decodeObject(dec *json.Decoder) (Object, error) { obj := make(Object) for { key, err := dec.Token() if err != nil { return nil, err } if delim, is := key.(json.Delim); is { switch delim { case '}': return obj, nil default: return obj, Errorf("Unexpected delim: %s", delim) } } // key is a Value value, err := decode(dec) obj[key] = value if err != nil { return obj, err } } }
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 getVal(dec *json.Decoder) (any, error) { t, err := dec.Token() if err != nil { return nil, err } switch tok := t.(type) { case json.Delim: switch tok { case '[': return decToSlice(dec) case '{': om := New() err := om.(*omap).unmarshalJSON(dec) if err != nil { return nil, err } _, err = dec.Token() // } return om, err case ']': return nil, endOfSlice case '}': return nil, fmt.Errorf("unexpected '}'") default: panic("unreachable code") } default: return tok, nil } }
func consumeExpectedToken(decoder *json.Decoder, expected json.Token) error { if actual, err := decoder.Token(); err != nil { return err } else if actual != expected { return fmt.Errorf("Expected %v, not %v", expected, actual) } else { return nil } }
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 (store Store) sliceFromJSONDecoder(dec *json.Decoder) ([]interface{}, error) { var slice []interface{} for { t, err := dec.Token() if err != nil { return slice, err } if delim, ok := t.(json.Delim); ok && delim.String() == "]" { return slice, nil } else if ok && delim.String() == "{" { item, err := store.treeBranchFromJSONDecoder(dec) if err != nil { return slice, err } slice = append(slice, item) } else { slice = append(slice, t) } } }
func ProcJsonString(dec *json.Decoder) int { count := 0.0 for { t, err := dec.Token() if err == io.EOF { break } if v, ok := t.(float64); ok { count += v } if t == nil { break } } return int(count) }
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 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 ProcJsonObject(dec *json.Decoder) (float64, bool) { count := 0.0 seen_red := false for { t, err := dec.Token() if err == io.EOF || t == nil { break } if v, ok := t.(json.Delim); ok { if v.String() == "{" { ncount, seen := ProcJsonObject(dec) if !seen { count += ncount } } else if v.String() == "}" { return count, seen_red } else if v.String() == "[" { ncount, _ := ProcJsonObject(dec) count += ncount } else if v.String() == "]" { return count, seen_red } } if v, ok := t.(string); ok { if v == "red" { seen_red = true } } if v, ok := t.(float64); ok { count += v } } return count, seen_red }
func decode(dec *json.Decoder) (Model, error) { tok, err := dec.Token() if err != nil { return nil, err } switch token := tok.(type) { case json.Delim: switch rune(token) { case '{': return decodeObject(dec) case '[': return decodeArray(dec) default: return nil, Errorf("Unexpected token %s", token) } default: return token, nil } }
func (store Store) treeItemFromJSONDecoder(dec *json.Decoder) (sops.TreeItem, error) { var item sops.TreeItem key, err := dec.Token() if err != nil { return item, err } if k, ok := key.(string); ok { item.Key = k } else if d, ok := key.(json.Delim); ok && d.String() == "}" { return item, errEndOfObject } else { return item, fmt.Errorf("Expected JSON object key, got %s of type %T instead", key, key) } value, err := dec.Token() if err != nil { return item, err } if delim, ok := value.(json.Delim); ok { if delim.String() == "[" { v, err := store.sliceFromJSONDecoder(dec) if err != nil { return item, err } item.Value = v } if delim.String() == "{" { v, err := store.treeBranchFromJSONDecoder(dec) if err != nil { return item, err } item.Value = v } } else { item.Value = value } return item, 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 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() }