예제 #1
0
// This example uses a Decoder to decode a stream of distinct JSON values.
func ExampleDecoder() {
	const rjsonStream = `
		{"Name": "Ed", "Text": "Knock knock."}
		{"Name": "Sam", "Text": "Who's there?"}
		{"Name": "Ed", "Text": "Go fmt."}
		{"Name": "Sam", "Text": "Go fmt who?"}
		{"Name": "Ed", "Text": "Go fmt yourself!"}
	`
	type Message struct {
		Name, Text string
	}
	dec := rjson.NewDecoder(strings.NewReader(rjsonStream))
	for {
		var m Message
		if err := dec.Decode(&m); err == io.EOF {
			break
		} else if err != nil {
			log.Fatal(err)
		}
		fmt.Printf("%s: %s\n", m.Name, m.Text)
	}
	// Output:
	// Ed: Knock knock.
	// Sam: Who's there?
	// Ed: Go fmt.
	// Sam: Go fmt who?
	// Ed: Go fmt yourself!
}
예제 #2
0
파일: conf.go 프로젝트: egonelbre/spexs2
func readBaseConfiguration(config string) *Conf {
	conf := &Conf{}
	dec := rjson.NewDecoder(bytes.NewBufferString(config))
	if err := dec.Decode(conf); err != nil {
		log.Println("Error in base configuration")
		log.Fatal(err)
	}
	return conf
}
예제 #3
0
파일: delta.go 프로젝트: egonelbre/spexs2
func ApplyObject(src interface{}, dest interface{}) {
	var buf bytes.Buffer
	enc := rjson.NewEncoder(&buf)
	if err := enc.Encode(src); err != nil {
		log.Println(err)
		return
	}
	dec := rjson.NewDecoder(&buf)
	if err := dec.Decode(dest); err != nil {
		log.Println(err)
	}
}
예제 #4
0
파일: main.go 프로젝트: egonelbre/spexs2
func main() {
	flag.Parse()
	if flag.NArg() > 0 {
		fmt.Fprintf(os.Stderr, "rjson reads from stdin only")
		os.Exit(2)
	}
	var marshal func(interface{}) ([]byte, error)
	if *jsonOut {
		if *indent == "" {
			marshal = json.Marshal
		} else {
			marshal = func(v interface{}) ([]byte, error) {
				return json.MarshalIndent(v, "", *indent)
			}
		}
	} else {
		if *indent == "" {
			marshal = func(v interface{}) ([]byte, error) {
				data, err := rjson.MarshalIndent(v, "", "")
				if err != nil {
					return data, err
				}
				// TODO: use Compact only when it compacts
				// identifiers too.
				var b bytes.Buffer
				if err := rjson.Compact(&b, data); err != nil {
					return nil, err
				}
				return b.Bytes(), nil
			}
		} else {
			marshal = func(v interface{}) ([]byte, error) {
				return rjson.MarshalIndent(v, "", *indent)
			}
		}
	}
	d := rjson.NewDecoder(os.Stdin)
	d.UseNumber()
	w := bufio.NewWriter(os.Stdout)

	err := stream(w, d, marshal)
	if err != nil {
		fmt.Fprintf(os.Stderr, "rjson: %v", err)
		os.Exit(1)
	}
}
예제 #5
0
파일: conf.go 프로젝트: egonelbre/spexs2
func NewConf(configFile string) *Conf {
	conf := readBaseConfiguration(baseConfiguration)

	if configFile == "" {
		return conf
	}

	data, err := ioutil.ReadFile(configFile)
	if err != nil {
		log.Println("Unable to read configuration file: ", configFile)
		log.Fatal(err)
	}

	regArg, _ := regexp.Compile(`^\s*(.*)=(.*)$`)
	for _, arg := range flag.Args() {
		if !regArg.MatchString(arg) {
			log.Fatal("Argument was not in correct form: ", arg)
		}
		tokens := regArg.FindStringSubmatch(arg)

		replace, _ := regexp.Compile(`\$` + tokens[1] + `(=[^$]*)?\$`)
		replacement := ([]byte)(tokens[2])
		data = replace.ReplaceAll(data, replacement)
	}

	regDefaults, _ := regexp.Compile(`\$[^\$]+\$`)
	regDefault, _ := regexp.Compile(`\$[^=]+=(.*)\$`)
	data = regDefaults.ReplaceAllFunc(data, func(repl []byte) []byte {
		defaults := regDefault.FindSubmatch(repl)
		if defaults != nil {
			return defaults[1]
		}
		return nil
	})

	dec := rjson.NewDecoder(bytes.NewReader(data))
	if err = dec.Decode(conf); err != nil {
		log.Println("Error in configuration file: ", configFile)
		log.Fatal(err)
	}

	return conf
}