data

package
Version: v2.0.4+incompatible Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Aug 26, 2016 License: MIT Imports: 4 Imported by: 69

Documentation

Overview

Package data holds custom types and functions for passing JSON between ratchet stages.

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func ObjectsFromJSON

func ObjectsFromJSON(d JSON) ([]map[string]interface{}, error)

ObjectsFromJSON is a helper for parsing JSON into a slice of generic maps/objects. The use-case is when a stage is expecting to receive either a JSON object or an array of JSON objects, and want to deal with it in a generic fashion.

Example
package main

import (
	"fmt"

	"github.com/dailyburn/ratchet/data"
)

func main() {
	d := []byte(`[{"One":1},
		      {"Two":2}]`)

	objects, _ := data.ObjectsFromJSON(d)

	fmt.Println(fmt.Sprintf("%+v", objects))
}
Output:

[map[One:1] map[Two:2]]

func ParseJSON

func ParseJSON(d JSON, v interface{}) error

ParseJSON is a simple wrapper for json.Unmarshal

Example
package main

import (
	"fmt"

	"github.com/dailyburn/ratchet/data"
)

type testStruct struct {
	A int
	B int
}

func main() {
	d := []byte(`{"A":1,"B":2}`)
	t := testStruct{}
	data.ParseJSON(d, &t)

	fmt.Println(fmt.Sprintf("%+v", t))
}
Output:

{A:1 B:2}

func ParseJSONSilent

func ParseJSONSilent(d JSON, v interface{}) error

ParseJSONSilent won't log output when unmarshaling fails. It can be used in cases where failure is expected.

Types

type JSON

type JSON []byte

JSON is the data type that is passed along all data channels. Under the covers, JSON is simply a []byte containing JSON data.

func JSONFromHeaderAndRows

func JSONFromHeaderAndRows(header []string, rows [][]interface{}) (JSON, error)

JSONFromHeaderAndRows takes the given header and rows of values, and turns it into a JSON array of objects.

Example
package main

import (
	"fmt"

	"github.com/dailyburn/ratchet/data"
)

func main() {
	header := []string{"A", "B", "C"}
	rows := [][]interface{}{
		[]interface{}{1, 2, 3},
		[]interface{}{4, 5, 6},
	}

	d, _ := data.JSONFromHeaderAndRows(header, rows)

	fmt.Println(fmt.Sprintf("%+v", string(d)))
}
Output:

[{"A":1,"B":2,"C":3},{"A":4,"B":5,"C":6}]

func NewJSON

func NewJSON(v interface{}) (JSON, error)

NewJSON is a simple wrapper for json.Marshal.

Example
package main

import (
	"fmt"

	"github.com/dailyburn/ratchet/data"
)

type testStruct struct {
	A int
	B int
}

func main() {
	t := testStruct{A: 1, B: 2}

	d, _ := data.NewJSON(t)

	fmt.Println(string(d))
}
Output:

{"A":1,"B":2}

Source Files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL