summaryrefslogtreecommitdiffstats
path: root/vendor/github.com/bennyscetbun/jsongo/README.md
diff options
context:
space:
mode:
authorOndrej Fabry <ofabry@cisco.com>2019-08-02 15:07:53 +0200
committerOndrej Fabry <ofabry@cisco.com>2019-08-02 15:07:53 +0200
commitca6003af1a7e1adb7d45879c2d5038bc05c2bb1a (patch)
tree97a3620b0fc5c7a0ee032fe7d12d37b6303cfb01 /vendor/github.com/bennyscetbun/jsongo/README.md
parent639870b5083a1e66f4584ec7a5f30492fcdb7168 (diff)
Migrate to modules, refactor Makefile and use Travis for CI
- migrate to Go modules and remove vendor - refactor Makefile - add version package and store version - split extras from the rest - use travis for CI Change-Id: I81b35220653b0f7c9a0fcdd4c527d691ec1e96c1 Signed-off-by: Ondrej Fabry <ofabry@cisco.com>
Diffstat (limited to 'vendor/github.com/bennyscetbun/jsongo/README.md')
-rw-r--r--vendor/github.com/bennyscetbun/jsongo/README.md574
1 files changed, 0 insertions, 574 deletions
diff --git a/vendor/github.com/bennyscetbun/jsongo/README.md b/vendor/github.com/bennyscetbun/jsongo/README.md
deleted file mode 100644
index ebc81c6..0000000
--- a/vendor/github.com/bennyscetbun/jsongo/README.md
+++ /dev/null
@@ -1,574 +0,0 @@
-jsongo
-======
-
-**Jsongo is a simple library for golang to help you build Json without static struct or map[string]interface**
-
-[json.Marshal](http://golang.org/pkg/encoding/json/#Marshal) and [json.Unmarshal](http://golang.org/pkg/encoding/json/#Unmarshal) have never been that easy
-
-**If you had only one function to look at, look at the "[At](#at)" function**
-
-***If you want an easy way to turn your json into a structure you should use the "[Print](#print)" function after unmarshalling json in a JSONNODE***
-
-You can find the doc on godoc.org [![GoDoc](https://godoc.org/github.com/bennyscetbun/jsongo?status.png)](https://godoc.org/github.com/bennyscetbun/jsongo)
-
-
-##JsonNode
-
-JsonNode is the basic Structure that you must use when using jsongo. It can either be a:
-- Map (jsongo.TypeMap)
-- Array (jsongo.TypeArray)
-- Value (jsongo.TypeValue) *Precisely a pointer store in an interface{}*
-- Undefined (jsongo.TypeUndefined) *default type*
-
-*When a JSONNode Type is set you cant change it without using Unset() first*
-____
-###Val
-####Synopsis:
-turn this JSONNode to TypeValue and set that value
-```go
-func (that *JSONNode) Val(val interface{})
-```
-
-####Examples
-#####code:
-```go
-package main
-
-import (
- "github.com/bennyscetbun/jsongo"
-)
-
-func main() {
- root := jsongo.JSONNode{}
- root.Val(42)
- root.DebugPrint("")
-}
-```
-#####output:
-```
-42
-```
-#####code:
-```go
-package main
-
-import (
- "github.com/bennyscetbun/jsongo"
-)
-type MyStruct struct {
- Member1 string
- Member2 int
-}
-
-func main() {
- root := jsongo.JSONNode{}
- root.Val(MyStruct{"The answer", 42})
- root.DebugPrint("")
-}
-```
-#####output:
-```
-{
- "Member1": "The answer",
- "Member2": 42
-}
-```
-_____
-###Array
-####Synopsis:
- Turn this JSONNode to a TypeArray and/or set the array size (reducing size will make you loose data)
-```go
-func (that *JSONNode) Array(size int) *[]JSONNode
-```
-
-####Examples
-#####code:
-```go
-package main
-
-import (
- "github.com/bennyscetbun/jsongo"
-)
-
-func main() {
- root := jsongo.JSONNode{}
- a := root.Array(4)
- for i := 0; i < 4; i++ {
- (*a)[i].Val(i)
- }
- root.DebugPrint("")
-}
-```
-#####output:
-```
-[
- 0,
- 1,
- 2,
- 3
-]
-```
-#####code:
-```go
-package main
-
-import (
- "github.com/bennyscetbun/jsongo"
-)
-
-func main() {
- root := jsongo.JSONNode{}
- a := root.Array(4)
- for i := 0; i < 4; i++ {
- (*a)[i].Val(i)
- }
- root.Array(2) //Here we reduce the size and we loose some data
- root.DebugPrint("")
-}
-```
-#####output:
-```
-[
- 0,
- 1
-]
-```
-____
-###Map
-####Synopsis:
-Turn this JSONNode to a TypeMap and/or Create a new element for key if necessary and return it
-```go
-func (that *JSONNode) Map(key string) *JSONNode
-```
-
-####Examples
-#####code:
-```go
-package main
-
-import (
- "github.com/bennyscetbun/jsongo"
-)
-
-func main() {
- root := jsongo.JSONNode{}
- root.Map("there").Val("you are")
- root.Map("here").Val("you should be")
- root.DebugPrint("")
-}
-```
-#####output:
-```
-{
- "here": "you should be",
- "there": "you are"
-}
-```
-____
-###At
-####Synopsis:
-Helps you move through your node by building them on the fly
-
-*val can be string or int only*
-
-*strings are keys for TypeMap*
-
-*ints are index in TypeArray (it will make array grow on the fly, so you should start to populate with the biggest index first)*
-```go
-func (that *JSONNode) At(val ...interface{}) *JSONNode
-```
-
-####Examples
-#####code:
-```go
-package main
-
-import (
- "github.com/bennyscetbun/jsongo"
-)
-
-func main() {
- root := jsongo.JSONNode{}
- root.At(4, "Who").Val("Let the dog out") //is equivalent to (*root.Array(5))[4].Map("Who").Val("Let the dog out")
- root.DebugPrint("")
-}
-```
-#####output:
-```
-[
- null,
- null,
- null,
- null,
- {
- "Who": "Let the dog out"
- }
-]
-```
-#####code:
-```go
-package main
-
-import (
- "github.com/bennyscetbun/jsongo"
-)
-
-func main() {
- root := jsongo.JSONNode{}
- root.At(4, "Who").Val("Let the dog out")
- //to win some time you can even even save a certain JSONNode
- node := root.At(2, "What")
- node.At("Can", "You").Val("do with that?")
- node.At("Do", "You", "Think").Val("Of that")
- root.DebugPrint("")
-}
-```
-#####output:
-```
-[
- null,
- null,
- {
- "What": {
- "Can": {
- "You": "do with that?"
- },
- "Do": {
- "You": {
- "Think": "Of that"
- }
- }
- }
- },
- null,
- {
- "Who": "Let the dog out"
- }
-]
-```
-____
-###Print
-####Synopsis:
-Helps you build your code by printing a go structure from the json you ve just unmarshaled
-
-```go
-func (that *JSONNode) Print()
-```
-
-____
-###Other Function
-There is plenty of other function, you should check the complete doc [![GoDoc](https://godoc.org/github.com/bennyscetbun/jsongo?status.png)](https://godoc.org/github.com/bennyscetbun/jsongo)
-
-####A last Example for fun
-#####code:
-```go
-package main
-
-import (
- "github.com/bennyscetbun/jsongo"
-)
-
-func ShowOnlyValue(current *jsongo.JSONNode) {
- switch current.GetType() {
- case jsongo.TypeValue:
- println(current.Get().(string))
- case jsongo.TypeMap:
- for _, key := range current.GetKeys() {
- ShowOnlyValue(current.At(key))
- }
- case jsongo.TypeArray:
- for _, key := range current.GetKeys() {
- ShowOnlyValue(current.At(key))
- }
- }
-}
-
-func main() {
- root := jsongo.JSONNode{}
- root.At(4, "Who").Val("Let the dog out")
- node := root.At(2, "What")
- node.At("Can", "You").Val("do with that?")
- node.At("Do", "You", "Think").Val("Of that")
- ShowOnlyValue(&root)
-}
-```
-#####output:
-```
-Of that
-do with that?
-Let the dog out
-```
-_____
-_____
-##Json Marshal/Unmarshal
-
-One of the main purpose of jsongo was to create Json from data without using static structure or map[string]interface.
-
-You can use the full power of the [encoding/json](http://golang.org/pkg/encoding/json/) package with jsongo.
-
-###Marshal
-####Example
-#####code:
-```go
-package main
-
-import (
- "encoding/json"
- "fmt"
- "github.com/bennyscetbun/jsongo"
-)
-
-type Test struct {
- Static string `json:"static"`
- Over int `json:"over"`
-}
-
-func main() {
- root := jsongo.JSONNode{}
- root.At("A", "AA", "AAA").Val(42)
-
- node := root.At("A", "AB")
- node.At(1).Val("Peace")
- node.At(0).Val(Test{"struct suck when you build json", 9000})
- root.At("B").Val("Oh Yeah")
-
- tojson, err := json.MarshalIndent(&root, "", " ")
- if err != nil {
- fmt.Printf("%s\n", err.Error())
- return
- }
- fmt.Printf("%s\n", tojson)
-}
-```
-#####output:
-```
-{
- "A": {
- "AA": {
- "AAA": 42
- },
- "AB": [
- {
- "static": "struct suck when you build json",
- "over": 9000
- },
- "Peace"
- ]
- },
- "B": "Oh Yeah"
-}
-```
-____
-###Unmarshal
-Unmarshal using JSONNode follow some simple rules:
-- Any TypeUndefined JSONNode will be set to the right type, any other type wont be changed
-- Array will grow if necessary
-- New keys will be added to Map
-- Values set to nil "*.Val(nil)*" will be turn into the type decide by Json
-- It will respect any current mapping and will return errors if needed
-
-You can set a node as "DontExpand" with the UnmarshalDontExpand function and thoose rules will apply:
-- The type wont be change for any type
-- Array wont grow
-- New keys wont be added to Map
-- Values set to nil "*.Val(nil)*" will be turn into the type decide by Json
-- It will respect any current mapping and will return errors if needed
-
-####Example of full expand
-#####code:
-```go
-package main
-
-import (
- "encoding/json"
- "github.com/bennyscetbun/jsongo"
- "fmt"
-)
-
-func main() {
- root := jsongo.JSONNode{}
- fromjson := `{
- "A": {
- "AA": {
- "AAA": 42
- },
- "AB": [
- {
- "static": "struct suck when you build json",
- "over": 9000
- },
- "Peace"
- ]
- },
- "B": "Oh Yeah"
- }`
- err := json.Unmarshal([]byte(fromjson), &root)
- if err != nil {
- fmt.Printf("%s\n", err.Error())
- return
- }
- root.DebugProspect(0, "\t")
-}
-```
-#####output:
-```
-Is of Type: TypeMap
-A:
- Is of Type: TypeMap
- AA:
- Is of Type: TypeMap
- AAA:
- Is of Type: TypeValue
- Value of type: float64
- 42
- AB:
- Is of Type: TypeArray
- [0]:
- Is of Type: TypeMap
- static:
- Is of Type: TypeValue
- Value of type: string
- struct suck when you build json
- over:
- Is of Type: TypeValue
- Value of type: float64
- 9000
- [1]:
- Is of Type: TypeValue
- Value of type: string
- Peace
-B:
- Is of Type: TypeValue
- Value of type: string
- Oh Yeah
-```
-####Example expand with mapping
-#####code:
-```go
-package main
-
-import (
- "encoding/json"
- "github.com/bennyscetbun/jsongo"
- "fmt"
-)
-type Test struct {
- Static string `json:"static"`
- Over int `json:"over"`
-}
-
-func main() {
- root := jsongo.JSONNode{}
- fromjson := `{
- "A": {
- "AA": {
- "AAA": 42
- },
- "AB": [
- {
- "static": "struct suck when you build json",
- "over": 9000
- },
- "Peace"
- ]
- },
- "B": "Oh Yeah"
- }`
- root.At("A", "AB", 0).Val(Test{})
- err := json.Unmarshal([]byte(fromjson), &root)
- if err != nil {
- fmt.Printf("%s\n", err.Error())
- return
- }
- root.DebugProspect(0, "\t")
-}
-```
-#####output:
-```
-Is of Type: TypeMap
-A:
- Is of Type: TypeMap
- AB:
- Is of Type: TypeArray
- [0]:
- Is of Type: TypeValue
- Value of type: main.Test
- {Static:struct suck when you build json Over:9000}
- [1]:
- Is of Type: TypeValue
- Value of type: string
- Peace
- AA:
- Is of Type: TypeMap
- AAA:
- Is of Type: TypeValue
- Value of type: float64
- 42
-B:
- Is of Type: TypeValue
- Value of type: string
- Oh Yeah
-```
-####Example expand with some UnmarshalDontExpand
-#####code:
-```go
-package main
-
-import (
- "encoding/json"
- "github.com/bennyscetbun/jsongo"
- "fmt"
-)
-type Test struct {
- Static string `json:"static"`
- Over int `json:"over"`
-}
-
-func main() {
- root := jsongo.JSONNode{}
- fromjson := `{
- "A": {
- "AA": {
- "AAA": 42
- },
- "AB": [
- {
- "static": "struct suck when you build json",
- "over": 9000
- },
- "Peace"
- ]
- },
- "B": "Oh Yeah"
- }`
- root.At("A", "AB").UnmarshalDontExpand(true, false).At(0).Val(Test{})
- err := json.Unmarshal([]byte(fromjson), &root)
- if err != nil {
- fmt.Printf("%s\n", err.Error())
- return
- }
- root.DebugProspect(0, "\t")
-}
-```
-#####output:
-```
-Is of Type: TypeMap
-A:
- Is of Type: TypeMap
- AB:
- Is of Type: TypeArray
- [0]:
- Is of Type: TypeValue
- Value of type: main.Test
- {Static:struct suck when you build json Over:9000}
- AA:
- Is of Type: TypeMap
- AAA:
- Is of Type: TypeValue
- Value of type: float64
- 42
-B:
- Is of Type: TypeValue
- Value of type: string
- Oh Yeah
-```