pax_global_header 0000666 0000000 0000000 00000000064 12602230340 0014502 g ustar 00root root 0000000 0000000 52 comment=1a9d0bb9f541897e62256577b352fdbc1fb4fd94
golang-objx-0.0~git20150928.0.1a9d0bb/ 0000775 0000000 0000000 00000000000 12602230340 0016564 5 ustar 00root root 0000000 0000000 golang-objx-0.0~git20150928.0.1a9d0bb/.gitignore 0000664 0000000 0000000 00000000374 12602230340 0020560 0 ustar 00root root 0000000 0000000 # Compiled Object files, Static and Dynamic libs (Shared Objects)
*.o
*.a
*.so
# Folders
_obj
_test
# Architecture specific extensions/prefixes
*.[568vq]
[568vq].out
*.cgo1.go
*.cgo2.c
_cgo_defun.c
_cgo_gotypes.go
_cgo_export.*
_testmain.go
*.exe
golang-objx-0.0~git20150928.0.1a9d0bb/LICENSE.md 0000664 0000000 0000000 00000002137 12602230340 0020173 0 ustar 00root root 0000000 0000000 objx - by Mat Ryer and Tyler Bunnell
The MIT License (MIT)
Copyright (c) 2014 Stretchr, Inc.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
golang-objx-0.0~git20150928.0.1a9d0bb/README.md 0000664 0000000 0000000 00000000131 12602230340 0020036 0 ustar 00root root 0000000 0000000 # objx
* Jump into the [API Documentation](http://godoc.org/github.com/stretchr/objx)
golang-objx-0.0~git20150928.0.1a9d0bb/accessors.go 0000664 0000000 0000000 00000010341 12602230340 0021077 0 ustar 00root root 0000000 0000000 package objx
import (
"fmt"
"regexp"
"strconv"
"strings"
)
// arrayAccesRegexString is the regex used to extract the array number
// from the access path
const arrayAccesRegexString = `^(.+)\[([0-9]+)\]$`
// arrayAccesRegex is the compiled arrayAccesRegexString
var arrayAccesRegex = regexp.MustCompile(arrayAccesRegexString)
// Get gets the value using the specified selector and
// returns it inside a new Obj object.
//
// If it cannot find the value, Get will return a nil
// value inside an instance of Obj.
//
// Get can only operate directly on map[string]interface{} and []interface.
//
// Example
//
// To access the title of the third chapter of the second book, do:
//
// o.Get("books[1].chapters[2].title")
func (m Map) Get(selector string) *Value {
rawObj := access(m, selector, nil, false, false)
return &Value{data: rawObj}
}
// Set sets the value using the specified selector and
// returns the object on which Set was called.
//
// Set can only operate directly on map[string]interface{} and []interface
//
// Example
//
// To set the title of the third chapter of the second book, do:
//
// o.Set("books[1].chapters[2].title","Time to Go")
func (m Map) Set(selector string, value interface{}) Map {
access(m, selector, value, true, false)
return m
}
// access accesses the object using the selector and performs the
// appropriate action.
func access(current, selector, value interface{}, isSet, panics bool) interface{} {
switch selector.(type) {
case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:
if array, ok := current.([]interface{}); ok {
index := intFromInterface(selector)
if index >= len(array) {
if panics {
panic(fmt.Sprintf("objx: Index %d is out of range. Slice only contains %d items.", index, len(array)))
}
return nil
}
return array[index]
}
return nil
case string:
selStr := selector.(string)
selSegs := strings.SplitN(selStr, PathSeparator, 2)
thisSel := selSegs[0]
index := -1
var err error
// https://github.com/stretchr/objx/issues/12
if strings.Contains(thisSel, "[") {
arrayMatches := arrayAccesRegex.FindStringSubmatch(thisSel)
if len(arrayMatches) > 0 {
// Get the key into the map
thisSel = arrayMatches[1]
// Get the index into the array at the key
index, err = strconv.Atoi(arrayMatches[2])
if err != nil {
// This should never happen. If it does, something has gone
// seriously wrong. Panic.
panic("objx: Array index is not an integer. Must use array[int].")
}
}
}
if curMap, ok := current.(Map); ok {
current = map[string]interface{}(curMap)
}
// get the object in question
switch current.(type) {
case map[string]interface{}:
curMSI := current.(map[string]interface{})
if len(selSegs) <= 1 && isSet {
curMSI[thisSel] = value
return nil
} else {
current = curMSI[thisSel]
}
default:
current = nil
}
if current == nil && panics {
panic(fmt.Sprintf("objx: '%v' invalid on object.", selector))
}
// do we need to access the item of an array?
if index > -1 {
if array, ok := current.([]interface{}); ok {
if index < len(array) {
current = array[index]
} else {
if panics {
panic(fmt.Sprintf("objx: Index %d is out of range. Slice only contains %d items.", index, len(array)))
}
current = nil
}
}
}
if len(selSegs) > 1 {
current = access(current, selSegs[1], value, isSet, panics)
}
}
return current
}
// intFromInterface converts an interface object to the largest
// representation of an unsigned integer using a type switch and
// assertions
func intFromInterface(selector interface{}) int {
var value int
switch selector.(type) {
case int:
value = selector.(int)
case int8:
value = int(selector.(int8))
case int16:
value = int(selector.(int16))
case int32:
value = int(selector.(int32))
case int64:
value = int(selector.(int64))
case uint:
value = int(selector.(uint))
case uint8:
value = int(selector.(uint8))
case uint16:
value = int(selector.(uint16))
case uint32:
value = int(selector.(uint32))
case uint64:
value = int(selector.(uint64))
default:
panic("objx: array access argument is not an integer type (this should never happen)")
}
return value
}
golang-objx-0.0~git20150928.0.1a9d0bb/accessors_test.go 0000664 0000000 0000000 00000012013 12602230340 0022134 0 ustar 00root root 0000000 0000000 package objx
import (
"github.com/stretchr/testify/assert"
"testing"
)
func TestAccessorsAccessGetSingleField(t *testing.T) {
current := map[string]interface{}{"name": "Tyler"}
assert.Equal(t, "Tyler", access(current, "name", nil, false, true))
}
func TestAccessorsAccessGetDeep(t *testing.T) {
current := map[string]interface{}{"name": map[string]interface{}{"first": "Tyler", "last": "Bunnell"}}
assert.Equal(t, "Tyler", access(current, "name.first", nil, false, true))
assert.Equal(t, "Bunnell", access(current, "name.last", nil, false, true))
}
func TestAccessorsAccessGetDeepDeep(t *testing.T) {
current := map[string]interface{}{"one": map[string]interface{}{"two": map[string]interface{}{"three": map[string]interface{}{"four": 4}}}}
assert.Equal(t, 4, access(current, "one.two.three.four", nil, false, true))
}
func TestAccessorsAccessGetInsideArray(t *testing.T) {
current := map[string]interface{}{"names": []interface{}{map[string]interface{}{"first": "Tyler", "last": "Bunnell"}, map[string]interface{}{"first": "Capitol", "last": "Bollocks"}}}
assert.Equal(t, "Tyler", access(current, "names[0].first", nil, false, true))
assert.Equal(t, "Bunnell", access(current, "names[0].last", nil, false, true))
assert.Equal(t, "Capitol", access(current, "names[1].first", nil, false, true))
assert.Equal(t, "Bollocks", access(current, "names[1].last", nil, false, true))
assert.Panics(t, func() {
access(current, "names[2]", nil, false, true)
})
assert.Nil(t, access(current, "names[2]", nil, false, false))
}
func TestAccessorsAccessGetFromArrayWithInt(t *testing.T) {
current := []interface{}{map[string]interface{}{"first": "Tyler", "last": "Bunnell"}, map[string]interface{}{"first": "Capitol", "last": "Bollocks"}}
one := access(current, 0, nil, false, false)
two := access(current, 1, nil, false, false)
three := access(current, 2, nil, false, false)
assert.Equal(t, "Tyler", one.(map[string]interface{})["first"])
assert.Equal(t, "Capitol", two.(map[string]interface{})["first"])
assert.Nil(t, three)
}
func TestAccessorsGet(t *testing.T) {
current := New(map[string]interface{}{"name": "Tyler"})
assert.Equal(t, "Tyler", current.Get("name").data)
}
func TestAccessorsAccessSetSingleField(t *testing.T) {
current := map[string]interface{}{"name": "Tyler"}
access(current, "name", "Mat", true, false)
assert.Equal(t, current["name"], "Mat")
access(current, "age", 29, true, true)
assert.Equal(t, current["age"], 29)
}
func TestAccessorsAccessSetSingleFieldNotExisting(t *testing.T) {
current := map[string]interface{}{}
access(current, "name", "Mat", true, false)
assert.Equal(t, current["name"], "Mat")
}
func TestAccessorsAccessSetDeep(t *testing.T) {
current := map[string]interface{}{"name": map[string]interface{}{"first": "Tyler", "last": "Bunnell"}}
access(current, "name.first", "Mat", true, true)
access(current, "name.last", "Ryer", true, true)
assert.Equal(t, "Mat", access(current, "name.first", nil, false, true))
assert.Equal(t, "Ryer", access(current, "name.last", nil, false, true))
}
func TestAccessorsAccessSetDeepDeep(t *testing.T) {
current := map[string]interface{}{"one": map[string]interface{}{"two": map[string]interface{}{"three": map[string]interface{}{"four": 4}}}}
access(current, "one.two.three.four", 5, true, true)
assert.Equal(t, 5, access(current, "one.two.three.four", nil, false, true))
}
func TestAccessorsAccessSetArray(t *testing.T) {
current := map[string]interface{}{"names": []interface{}{"Tyler"}}
access(current, "names[0]", "Mat", true, true)
assert.Equal(t, "Mat", access(current, "names[0]", nil, false, true))
}
func TestAccessorsAccessSetInsideArray(t *testing.T) {
current := map[string]interface{}{"names": []interface{}{map[string]interface{}{"first": "Tyler", "last": "Bunnell"}, map[string]interface{}{"first": "Capitol", "last": "Bollocks"}}}
access(current, "names[0].first", "Mat", true, true)
access(current, "names[0].last", "Ryer", true, true)
access(current, "names[1].first", "Captain", true, true)
access(current, "names[1].last", "Underpants", true, true)
assert.Equal(t, "Mat", access(current, "names[0].first", nil, false, true))
assert.Equal(t, "Ryer", access(current, "names[0].last", nil, false, true))
assert.Equal(t, "Captain", access(current, "names[1].first", nil, false, true))
assert.Equal(t, "Underpants", access(current, "names[1].last", nil, false, true))
}
func TestAccessorsAccessSetFromArrayWithInt(t *testing.T) {
current := []interface{}{map[string]interface{}{"first": "Tyler", "last": "Bunnell"}, map[string]interface{}{"first": "Capitol", "last": "Bollocks"}}
one := access(current, 0, nil, false, false)
two := access(current, 1, nil, false, false)
three := access(current, 2, nil, false, false)
assert.Equal(t, "Tyler", one.(map[string]interface{})["first"])
assert.Equal(t, "Capitol", two.(map[string]interface{})["first"])
assert.Nil(t, three)
}
func TestAccessorsSet(t *testing.T) {
current := New(map[string]interface{}{"name": "Tyler"})
current.Set("name", "Mat")
assert.Equal(t, "Mat", current.Get("name").data)
}
golang-objx-0.0~git20150928.0.1a9d0bb/codegen/ 0000775 0000000 0000000 00000000000 12602230340 0020170 5 ustar 00root root 0000000 0000000 golang-objx-0.0~git20150928.0.1a9d0bb/codegen/array-access.txt 0000664 0000000 0000000 00000000530 12602230340 0023304 0 ustar 00root root 0000000 0000000 case []{1}:
a := object.([]{1})
if isSet {
a[index] = value.({1})
} else {
if index >= len(a) {
if panics {
panic(fmt.Sprintf("objx: Index %d is out of range because the []{1} only contains %d items.", index, len(a)))
}
return nil
} else {
return a[index]
}
}
golang-objx-0.0~git20150928.0.1a9d0bb/codegen/index.html 0000664 0000000 0000000 00000002614 12602230340 0022170 0 ustar 00root root 0000000 0000000
Codegen
Template
Use {x} as a placeholder for each argument.
Arguments (comma separated)
One block per line
Output
golang-objx-0.0~git20150928.0.1a9d0bb/codegen/template.txt 0000664 0000000 0000000 00000015362 12602230340 0022553 0 ustar 00root root 0000000 0000000 /*
{4} ({1} and []{1})
--------------------------------------------------
*/
// {4} gets the value as a {1}, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) {4}(optionalDefault ...{1}) {1} {
if s, ok := v.data.({1}); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return {3}
}
// Must{4} gets the value as a {1}.
//
// Panics if the object is not a {1}.
func (v *Value) Must{4}() {1} {
return v.data.({1})
}
// {4}Slice gets the value as a []{1}, returns the optionalDefault
// value or nil if the value is not a []{1}.
func (v *Value) {4}Slice(optionalDefault ...[]{1}) []{1} {
if s, ok := v.data.([]{1}); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// Must{4}Slice gets the value as a []{1}.
//
// Panics if the object is not a []{1}.
func (v *Value) Must{4}Slice() []{1} {
return v.data.([]{1})
}
// Is{4} gets whether the object contained is a {1} or not.
func (v *Value) Is{4}() bool {
_, ok := v.data.({1})
return ok
}
// Is{4}Slice gets whether the object contained is a []{1} or not.
func (v *Value) Is{4}Slice() bool {
_, ok := v.data.([]{1})
return ok
}
// Each{4} calls the specified callback for each object
// in the []{1}.
//
// Panics if the object is the wrong type.
func (v *Value) Each{4}(callback func(int, {1}) bool) *Value {
for index, val := range v.Must{4}Slice() {
carryon := callback(index, val)
if carryon == false {
break
}
}
return v
}
// Where{4} uses the specified decider function to select items
// from the []{1}. The object contained in the result will contain
// only the selected items.
func (v *Value) Where{4}(decider func(int, {1}) bool) *Value {
var selected []{1}
v.Each{4}(func(index int, val {1}) bool {
shouldSelect := decider(index, val)
if shouldSelect == false {
selected = append(selected, val)
}
return true
})
return &Value{data:selected}
}
// Group{4} uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]{1}.
func (v *Value) Group{4}(grouper func(int, {1}) string) *Value {
groups := make(map[string][]{1})
v.Each{4}(func(index int, val {1}) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]{1}, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data:groups}
}
// Replace{4} uses the specified function to replace each {1}s
// by iterating each item. The data in the returned result will be a
// []{1} containing the replaced items.
func (v *Value) Replace{4}(replacer func(int, {1}) {1}) *Value {
arr := v.Must{4}Slice()
replaced := make([]{1}, len(arr))
v.Each{4}(func(index int, val {1}) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data:replaced}
}
// Collect{4} uses the specified collector function to collect a value
// for each of the {1}s in the slice. The data returned will be a
// []interface{}.
func (v *Value) Collect{4}(collector func(int, {1}) interface{}) *Value {
arr := v.Must{4}Slice()
collected := make([]interface{}, len(arr))
v.Each{4}(func(index int, val {1}) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data:collected}
}
// ************************************************************
// TESTS
// ************************************************************
func Test{4}(t *testing.T) {
val := {1}( {2} )
m := map[string]interface{}{"value": val, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").{4}())
assert.Equal(t, val, New(m).Get("value").Must{4}())
assert.Equal(t, {1}({3}), New(m).Get("nothing").{4}())
assert.Equal(t, val, New(m).Get("nothing").{4}({2}))
assert.Panics(t, func() {
New(m).Get("age").Must{4}()
})
}
func Test{4}Slice(t *testing.T) {
val := {1}( {2} )
m := map[string]interface{}{"value": []{1}{ val }, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").{4}Slice()[0])
assert.Equal(t, val, New(m).Get("value").Must{4}Slice()[0])
assert.Equal(t, []{1}(nil), New(m).Get("nothing").{4}Slice())
assert.Equal(t, val, New(m).Get("nothing").{4}Slice( []{1}{ {1}({2}) } )[0])
assert.Panics(t, func() {
New(m).Get("nothing").Must{4}Slice()
})
}
func TestIs{4}(t *testing.T) {
var v *Value
v = &Value{data: {1}({2})}
assert.True(t, v.Is{4}())
v = &Value{data: []{1}{ {1}({2}) }}
assert.True(t, v.Is{4}Slice())
}
func TestEach{4}(t *testing.T) {
v := &Value{data: []{1}{ {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}) }}
count := 0
replacedVals := make([]{1}, 0)
assert.Equal(t, v, v.Each{4}(func(i int, val {1}) bool {
count++
replacedVals = append(replacedVals, val)
// abort early
if i == 2 {
return false
}
return true
}))
assert.Equal(t, count, 3)
assert.Equal(t, replacedVals[0], v.Must{4}Slice()[0])
assert.Equal(t, replacedVals[1], v.Must{4}Slice()[1])
assert.Equal(t, replacedVals[2], v.Must{4}Slice()[2])
}
func TestWhere{4}(t *testing.T) {
v := &Value{data: []{1}{ {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}) }}
selected := v.Where{4}(func(i int, val {1}) bool {
return i%2==0
}).Must{4}Slice()
assert.Equal(t, 3, len(selected))
}
func TestGroup{4}(t *testing.T) {
v := &Value{data: []{1}{ {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}) }}
grouped := v.Group{4}(func(i int, val {1}) string {
return fmt.Sprintf("%v", i%2==0)
}).data.(map[string][]{1})
assert.Equal(t, 2, len(grouped))
assert.Equal(t, 3, len(grouped["true"]))
assert.Equal(t, 3, len(grouped["false"]))
}
func TestReplace{4}(t *testing.T) {
v := &Value{data: []{1}{ {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}) }}
rawArr := v.Must{4}Slice()
replaced := v.Replace{4}(func(index int, val {1}) {1} {
if index < len(rawArr)-1 {
return rawArr[index+1]
}
return rawArr[0]
})
replacedArr := replaced.Must{4}Slice()
if assert.Equal(t, 6, len(replacedArr)) {
assert.Equal(t, replacedArr[0], rawArr[1])
assert.Equal(t, replacedArr[1], rawArr[2])
assert.Equal(t, replacedArr[2], rawArr[3])
assert.Equal(t, replacedArr[3], rawArr[4])
assert.Equal(t, replacedArr[4], rawArr[5])
assert.Equal(t, replacedArr[5], rawArr[0])
}
}
func TestCollect{4}(t *testing.T) {
v := &Value{data: []{1}{ {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}) }}
collected := v.Collect{4}(func(index int, val {1}) interface{} {
return index
})
collectedArr := collected.MustInterSlice()
if assert.Equal(t, 6, len(collectedArr)) {
assert.Equal(t, collectedArr[0], 0)
assert.Equal(t, collectedArr[1], 1)
assert.Equal(t, collectedArr[2], 2)
assert.Equal(t, collectedArr[3], 3)
assert.Equal(t, collectedArr[4], 4)
assert.Equal(t, collectedArr[5], 5)
}
}
golang-objx-0.0~git20150928.0.1a9d0bb/codegen/types_list.txt 0000664 0000000 0000000 00000001107 12602230340 0023127 0 ustar 00root root 0000000 0000000 Interface,interface{},"something",nil,Inter
Map,map[string]interface{},map[string]interface{}{"name":"Tyler"},nil,MSI
ObjxMap,(Map),New(1),New(nil),ObjxMap
Bool,bool,true,false,Bool
String,string,"hello","",Str
Int,int,1,0,Int
Int8,int8,1,0,Int8
Int16,int16,1,0,Int16
Int32,int32,1,0,Int32
Int64,int64,1,0,Int64
Uint,uint,1,0,Uint
Uint8,uint8,1,0,Uint8
Uint16,uint16,1,0,Uint16
Uint32,uint32,1,0,Uint32
Uint64,uint64,1,0,Uint64
Uintptr,uintptr,1,0,Uintptr
Float32,float32,1,0,Float32
Float64,float64,1,0,Float64
Complex64,complex64,1,0,Complex64
Complex128,complex128,1,0,Complex128
golang-objx-0.0~git20150928.0.1a9d0bb/constants.go 0000664 0000000 0000000 00000000505 12602230340 0021127 0 ustar 00root root 0000000 0000000 package objx
const (
// PathSeparator is the character used to separate the elements
// of the keypath.
//
// For example, `location.address.city`
PathSeparator string = "."
// SignatureSeparator is the character that is used to
// separate the Base64 string from the security signature.
SignatureSeparator = "_"
)
golang-objx-0.0~git20150928.0.1a9d0bb/conversions.go 0000664 0000000 0000000 00000004775 12602230340 0021500 0 ustar 00root root 0000000 0000000 package objx
import (
"bytes"
"encoding/base64"
"encoding/json"
"errors"
"fmt"
"net/url"
)
// JSON converts the contained object to a JSON string
// representation
func (m Map) JSON() (string, error) {
result, err := json.Marshal(m)
if err != nil {
err = errors.New("objx: JSON encode failed with: " + err.Error())
}
return string(result), err
}
// MustJSON converts the contained object to a JSON string
// representation and panics if there is an error
func (m Map) MustJSON() string {
result, err := m.JSON()
if err != nil {
panic(err.Error())
}
return result
}
// Base64 converts the contained object to a Base64 string
// representation of the JSON string representation
func (m Map) Base64() (string, error) {
var buf bytes.Buffer
jsonData, err := m.JSON()
if err != nil {
return "", err
}
encoder := base64.NewEncoder(base64.StdEncoding, &buf)
encoder.Write([]byte(jsonData))
encoder.Close()
return buf.String(), nil
}
// MustBase64 converts the contained object to a Base64 string
// representation of the JSON string representation and panics
// if there is an error
func (m Map) MustBase64() string {
result, err := m.Base64()
if err != nil {
panic(err.Error())
}
return result
}
// SignedBase64 converts the contained object to a Base64 string
// representation of the JSON string representation and signs it
// using the provided key.
func (m Map) SignedBase64(key string) (string, error) {
base64, err := m.Base64()
if err != nil {
return "", err
}
sig := HashWithKey(base64, key)
return base64 + SignatureSeparator + sig, nil
}
// MustSignedBase64 converts the contained object to a Base64 string
// representation of the JSON string representation and signs it
// using the provided key and panics if there is an error
func (m Map) MustSignedBase64(key string) string {
result, err := m.SignedBase64(key)
if err != nil {
panic(err.Error())
}
return result
}
/*
URL Query
------------------------------------------------
*/
// URLValues creates a url.Values object from an Obj. This
// function requires that the wrapped object be a map[string]interface{}
func (m Map) URLValues() url.Values {
vals := make(url.Values)
for k, v := range m {
//TODO: can this be done without sprintf?
vals.Set(k, fmt.Sprintf("%v", v))
}
return vals
}
// URLQuery gets an encoded URL query representing the given
// Obj. This function requires that the wrapped object be a
// map[string]interface{}
func (m Map) URLQuery() (string, error) {
return m.URLValues().Encode(), nil
}
golang-objx-0.0~git20150928.0.1a9d0bb/conversions_test.go 0000664 0000000 0000000 00000003007 12602230340 0022522 0 ustar 00root root 0000000 0000000 package objx
import (
"github.com/stretchr/testify/assert"
"testing"
)
func TestConversionJSON(t *testing.T) {
jsonString := `{"name":"Mat"}`
o := MustFromJSON(jsonString)
result, err := o.JSON()
if assert.NoError(t, err) {
assert.Equal(t, jsonString, result)
}
assert.Equal(t, jsonString, o.MustJSON())
}
func TestConversionJSONWithError(t *testing.T) {
o := MSI()
o["test"] = func() {}
assert.Panics(t, func() {
o.MustJSON()
})
_, err := o.JSON()
assert.Error(t, err)
}
func TestConversionBase64(t *testing.T) {
o := New(map[string]interface{}{"name": "Mat"})
result, err := o.Base64()
if assert.NoError(t, err) {
assert.Equal(t, "eyJuYW1lIjoiTWF0In0=", result)
}
assert.Equal(t, "eyJuYW1lIjoiTWF0In0=", o.MustBase64())
}
func TestConversionBase64WithError(t *testing.T) {
o := MSI()
o["test"] = func() {}
assert.Panics(t, func() {
o.MustBase64()
})
_, err := o.Base64()
assert.Error(t, err)
}
func TestConversionSignedBase64(t *testing.T) {
o := New(map[string]interface{}{"name": "Mat"})
result, err := o.SignedBase64("key")
if assert.NoError(t, err) {
assert.Equal(t, "eyJuYW1lIjoiTWF0In0=_67ee82916f90b2c0d68c903266e8998c9ef0c3d6", result)
}
assert.Equal(t, "eyJuYW1lIjoiTWF0In0=_67ee82916f90b2c0d68c903266e8998c9ef0c3d6", o.MustSignedBase64("key"))
}
func TestConversionSignedBase64WithError(t *testing.T) {
o := MSI()
o["test"] = func() {}
assert.Panics(t, func() {
o.MustSignedBase64("key")
})
_, err := o.SignedBase64("key")
assert.Error(t, err)
}
golang-objx-0.0~git20150928.0.1a9d0bb/doc.go 0000664 0000000 0000000 00000004443 12602230340 0017665 0 ustar 00root root 0000000 0000000 // objx - Go package for dealing with maps, slices, JSON and other data.
//
// Overview
//
// Objx provides the `objx.Map` type, which is a `map[string]interface{}` that exposes
// a powerful `Get` method (among others) that allows you to easily and quickly get
// access to data within the map, without having to worry too much about type assertions,
// missing data, default values etc.
//
// Pattern
//
// Objx uses a preditable pattern to make access data from within `map[string]interface{}'s
// easy.
//
// Call one of the `objx.` functions to create your `objx.Map` to get going:
//
// m, err := objx.FromJSON(json)
//
// NOTE: Any methods or functions with the `Must` prefix will panic if something goes wrong,
// the rest will be optimistic and try to figure things out without panicking.
//
// Use `Get` to access the value you're interested in. You can use dot and array
// notation too:
//
// m.Get("places[0].latlng")
//
// Once you have saught the `Value` you're interested in, you can use the `Is*` methods
// to determine its type.
//
// if m.Get("code").IsStr() { /* ... */ }
//
// Or you can just assume the type, and use one of the strong type methods to
// extract the real value:
//
// m.Get("code").Int()
//
// If there's no value there (or if it's the wrong type) then a default value
// will be returned, or you can be explicit about the default value.
//
// Get("code").Int(-1)
//
// If you're dealing with a slice of data as a value, Objx provides many useful
// methods for iterating, manipulating and selecting that data. You can find out more
// by exploring the index below.
//
// Reading data
//
// A simple example of how to use Objx:
//
// // use MustFromJSON to make an objx.Map from some JSON
// m := objx.MustFromJSON(`{"name": "Mat", "age": 30}`)
//
// // get the details
// name := m.Get("name").Str()
// age := m.Get("age").Int()
//
// // get their nickname (or use their name if they
// // don't have one)
// nickname := m.Get("nickname").Str(name)
//
// Ranging
//
// Since `objx.Map` is a `map[string]interface{}` you can treat it as such. For
// example, to `range` the data, do what you would expect:
//
// m := objx.MustFromJSON(json)
// for key, value := range m {
//
// /* ... do your magic ... */
//
// }
package objx
golang-objx-0.0~git20150928.0.1a9d0bb/fixture_test.go 0000664 0000000 0000000 00000004255 12602230340 0021646 0 ustar 00root root 0000000 0000000 package objx
import (
"github.com/stretchr/testify/assert"
"testing"
)
var fixtures = []struct {
// name is the name of the fixture (used for reporting
// failures)
name string
// data is the JSON data to be worked on
data string
// get is the argument(s) to pass to Get
get interface{}
// output is the expected output
output interface{}
}{
{
name: "Simple get",
data: `{"name": "Mat"}`,
get: "name",
output: "Mat",
},
{
name: "Get with dot notation",
data: `{"address": {"city": "Boulder"}}`,
get: "address.city",
output: "Boulder",
},
{
name: "Deep get with dot notation",
data: `{"one": {"two": {"three": {"four": "hello"}}}}`,
get: "one.two.three.four",
output: "hello",
},
{
name: "Get missing with dot notation",
data: `{"one": {"two": {"three": {"four": "hello"}}}}`,
get: "one.ten",
output: nil,
},
{
name: "Get with array notation",
data: `{"tags": ["one", "two", "three"]}`,
get: "tags[1]",
output: "two",
},
{
name: "Get with array and dot notation",
data: `{"types": { "tags": ["one", "two", "three"]}}`,
get: "types.tags[1]",
output: "two",
},
{
name: "Get with array and dot notation - field after array",
data: `{"tags": [{"name":"one"}, {"name":"two"}, {"name":"three"}]}`,
get: "tags[1].name",
output: "two",
},
{
name: "Complex get with array and dot notation",
data: `{"tags": [{"list": [{"one":"pizza"}]}]}`,
get: "tags[0].list[0].one",
output: "pizza",
},
{
name: "Get field from within string should be nil",
data: `{"name":"Tyler"}`,
get: "name.something",
output: nil,
},
{
name: "Get field from within string (using array accessor) should be nil",
data: `{"numbers":["one", "two", "three"]}`,
get: "numbers[0].nope",
output: nil,
},
}
func TestFixtures(t *testing.T) {
for _, fixture := range fixtures {
m := MustFromJSON(fixture.data)
// get the value
t.Logf("Running get fixture: \"%s\" (%v)", fixture.name, fixture)
value := m.Get(fixture.get.(string))
// make sure it matches
assert.Equal(t, fixture.output, value.data,
"Get fixture \"%s\" failed: %v", fixture.name, fixture,
)
}
}
golang-objx-0.0~git20150928.0.1a9d0bb/map.go 0000664 0000000 0000000 00000012466 12602230340 0017701 0 ustar 00root root 0000000 0000000 package objx
import (
"encoding/base64"
"encoding/json"
"errors"
"io/ioutil"
"net/url"
"strings"
)
// MSIConvertable is an interface that defines methods for converting your
// custom types to a map[string]interface{} representation.
type MSIConvertable interface {
// MSI gets a map[string]interface{} (msi) representing the
// object.
MSI() map[string]interface{}
}
// Map provides extended functionality for working with
// untyped data, in particular map[string]interface (msi).
type Map map[string]interface{}
// Value returns the internal value instance
func (m Map) Value() *Value {
return &Value{data: m}
}
// Nil represents a nil Map.
var Nil Map = New(nil)
// New creates a new Map containing the map[string]interface{} in the data argument.
// If the data argument is not a map[string]interface, New attempts to call the
// MSI() method on the MSIConvertable interface to create one.
func New(data interface{}) Map {
if _, ok := data.(map[string]interface{}); !ok {
if converter, ok := data.(MSIConvertable); ok {
data = converter.MSI()
} else {
return nil
}
}
return Map(data.(map[string]interface{}))
}
// MSI creates a map[string]interface{} and puts it inside a new Map.
//
// The arguments follow a key, value pattern.
//
// Panics
//
// Panics if any key arugment is non-string or if there are an odd number of arguments.
//
// Example
//
// To easily create Maps:
//
// m := objx.MSI("name", "Mat", "age", 29, "subobj", objx.MSI("active", true))
//
// // creates an Map equivalent to
// m := objx.New(map[string]interface{}{"name": "Mat", "age": 29, "subobj": map[string]interface{}{"active": true}})
func MSI(keyAndValuePairs ...interface{}) Map {
newMap := make(map[string]interface{})
keyAndValuePairsLen := len(keyAndValuePairs)
if keyAndValuePairsLen%2 != 0 {
panic("objx: MSI must have an even number of arguments following the 'key, value' pattern.")
}
for i := 0; i < keyAndValuePairsLen; i = i + 2 {
key := keyAndValuePairs[i]
value := keyAndValuePairs[i+1]
// make sure the key is a string
keyString, keyStringOK := key.(string)
if !keyStringOK {
panic("objx: MSI must follow 'string, interface{}' pattern. " + keyString + " is not a valid key.")
}
newMap[keyString] = value
}
return New(newMap)
}
// ****** Conversion Constructors
// MustFromJSON creates a new Map containing the data specified in the
// jsonString.
//
// Panics if the JSON is invalid.
func MustFromJSON(jsonString string) Map {
o, err := FromJSON(jsonString)
if err != nil {
panic("objx: MustFromJSON failed with error: " + err.Error())
}
return o
}
// FromJSON creates a new Map containing the data specified in the
// jsonString.
//
// Returns an error if the JSON is invalid.
func FromJSON(jsonString string) (Map, error) {
var data interface{}
err := json.Unmarshal([]byte(jsonString), &data)
if err != nil {
return Nil, err
}
return New(data), nil
}
// FromBase64 creates a new Obj containing the data specified
// in the Base64 string.
//
// The string is an encoded JSON string returned by Base64
func FromBase64(base64String string) (Map, error) {
decoder := base64.NewDecoder(base64.StdEncoding, strings.NewReader(base64String))
decoded, err := ioutil.ReadAll(decoder)
if err != nil {
return nil, err
}
return FromJSON(string(decoded))
}
// MustFromBase64 creates a new Obj containing the data specified
// in the Base64 string and panics if there is an error.
//
// The string is an encoded JSON string returned by Base64
func MustFromBase64(base64String string) Map {
result, err := FromBase64(base64String)
if err != nil {
panic("objx: MustFromBase64 failed with error: " + err.Error())
}
return result
}
// FromSignedBase64 creates a new Obj containing the data specified
// in the Base64 string.
//
// The string is an encoded JSON string returned by SignedBase64
func FromSignedBase64(base64String, key string) (Map, error) {
parts := strings.Split(base64String, SignatureSeparator)
if len(parts) != 2 {
return nil, errors.New("objx: Signed base64 string is malformed.")
}
sig := HashWithKey(parts[0], key)
if parts[1] != sig {
return nil, errors.New("objx: Signature for base64 data does not match.")
}
return FromBase64(parts[0])
}
// MustFromSignedBase64 creates a new Obj containing the data specified
// in the Base64 string and panics if there is an error.
//
// The string is an encoded JSON string returned by Base64
func MustFromSignedBase64(base64String, key string) Map {
result, err := FromSignedBase64(base64String, key)
if err != nil {
panic("objx: MustFromSignedBase64 failed with error: " + err.Error())
}
return result
}
// FromURLQuery generates a new Obj by parsing the specified
// query.
//
// For queries with multiple values, the first value is selected.
func FromURLQuery(query string) (Map, error) {
vals, err := url.ParseQuery(query)
if err != nil {
return nil, err
}
m := make(map[string]interface{})
for k, vals := range vals {
m[k] = vals[0]
}
return New(m), nil
}
// MustFromURLQuery generates a new Obj by parsing the specified
// query.
//
// For queries with multiple values, the first value is selected.
//
// Panics if it encounters an error
func MustFromURLQuery(query string) Map {
o, err := FromURLQuery(query)
if err != nil {
panic("objx: MustFromURLQuery failed with error: " + err.Error())
}
return o
}
golang-objx-0.0~git20150928.0.1a9d0bb/map_for_test.go 0000664 0000000 0000000 00000000367 12602230340 0021603 0 ustar 00root root 0000000 0000000 package objx
var TestMap map[string]interface{} = map[string]interface{}{
"name": "Tyler",
"address": map[string]interface{}{
"city": "Salt Lake City",
"state": "UT",
},
"numbers": []interface{}{"one", "two", "three", "four", "five"},
}
golang-objx-0.0~git20150928.0.1a9d0bb/map_test.go 0000664 0000000 0000000 00000005124 12602230340 0020731 0 ustar 00root root 0000000 0000000 package objx
import (
"github.com/stretchr/testify/assert"
"testing"
)
type Convertable struct {
name string
}
func (c *Convertable) MSI() map[string]interface{} {
return map[string]interface{}{"name": c.name}
}
type Unconvertable struct {
name string
}
func TestMapCreation(t *testing.T) {
o := New(nil)
assert.Nil(t, o)
o = New("Tyler")
assert.Nil(t, o)
unconvertable := &Unconvertable{name: "Tyler"}
o = New(unconvertable)
assert.Nil(t, o)
convertable := &Convertable{name: "Tyler"}
o = New(convertable)
if assert.NotNil(t, convertable) {
assert.Equal(t, "Tyler", o["name"], "Tyler")
}
o = MSI()
if assert.NotNil(t, o) {
assert.NotNil(t, o)
}
o = MSI("name", "Tyler")
if assert.NotNil(t, o) {
if assert.NotNil(t, o) {
assert.Equal(t, o["name"], "Tyler")
}
}
}
func TestMapMustFromJSONWithError(t *testing.T) {
_, err := FromJSON(`"name":"Mat"}`)
assert.Error(t, err)
}
func TestMapFromJSON(t *testing.T) {
o := MustFromJSON(`{"name":"Mat"}`)
if assert.NotNil(t, o) {
if assert.NotNil(t, o) {
assert.Equal(t, "Mat", o["name"])
}
}
}
func TestMapFromJSONWithError(t *testing.T) {
var m Map
assert.Panics(t, func() {
m = MustFromJSON(`"name":"Mat"}`)
})
assert.Nil(t, m)
}
func TestMapFromBase64String(t *testing.T) {
base64String := "eyJuYW1lIjoiTWF0In0="
o, err := FromBase64(base64String)
if assert.NoError(t, err) {
assert.Equal(t, o.Get("name").Str(), "Mat")
}
assert.Equal(t, MustFromBase64(base64String).Get("name").Str(), "Mat")
}
func TestMapFromBase64StringWithError(t *testing.T) {
base64String := "eyJuYW1lIjoiTWFasd0In0="
_, err := FromBase64(base64String)
assert.Error(t, err)
assert.Panics(t, func() {
MustFromBase64(base64String)
})
}
func TestMapFromSignedBase64String(t *testing.T) {
base64String := "eyJuYW1lIjoiTWF0In0=_67ee82916f90b2c0d68c903266e8998c9ef0c3d6"
o, err := FromSignedBase64(base64String, "key")
if assert.NoError(t, err) {
assert.Equal(t, o.Get("name").Str(), "Mat")
}
assert.Equal(t, MustFromSignedBase64(base64String, "key").Get("name").Str(), "Mat")
}
func TestMapFromSignedBase64StringWithError(t *testing.T) {
base64String := "eyJuYW1lasdIjoiTWF0In0=_67ee82916f90b2c0d68c903266e8998c9ef0c3d6"
_, err := FromSignedBase64(base64String, "key")
assert.Error(t, err)
assert.Panics(t, func() {
MustFromSignedBase64(base64String, "key")
})
}
func TestMapFromURLQuery(t *testing.T) {
m, err := FromURLQuery("name=tyler&state=UT")
if assert.NoError(t, err) && assert.NotNil(t, m) {
assert.Equal(t, "tyler", m.Get("name").Str())
assert.Equal(t, "UT", m.Get("state").Str())
}
}
golang-objx-0.0~git20150928.0.1a9d0bb/mutations.go 0000664 0000000 0000000 00000004073 12602230340 0021142 0 ustar 00root root 0000000 0000000 package objx
// Exclude returns a new Map with the keys in the specified []string
// excluded.
func (d Map) Exclude(exclude []string) Map {
excluded := make(Map)
for k, v := range d {
var shouldInclude bool = true
for _, toExclude := range exclude {
if k == toExclude {
shouldInclude = false
break
}
}
if shouldInclude {
excluded[k] = v
}
}
return excluded
}
// Copy creates a shallow copy of the Obj.
func (m Map) Copy() Map {
copied := make(map[string]interface{})
for k, v := range m {
copied[k] = v
}
return New(copied)
}
// Merge blends the specified map with a copy of this map and returns the result.
//
// Keys that appear in both will be selected from the specified map.
// This method requires that the wrapped object be a map[string]interface{}
func (m Map) Merge(merge Map) Map {
return m.Copy().MergeHere(merge)
}
// Merge blends the specified map with this map and returns the current map.
//
// Keys that appear in both will be selected from the specified map. The original map
// will be modified. This method requires that
// the wrapped object be a map[string]interface{}
func (m Map) MergeHere(merge Map) Map {
for k, v := range merge {
m[k] = v
}
return m
}
// Transform builds a new Obj giving the transformer a chance
// to change the keys and values as it goes. This method requires that
// the wrapped object be a map[string]interface{}
func (m Map) Transform(transformer func(key string, value interface{}) (string, interface{})) Map {
newMap := make(map[string]interface{})
for k, v := range m {
modifiedKey, modifiedVal := transformer(k, v)
newMap[modifiedKey] = modifiedVal
}
return New(newMap)
}
// TransformKeys builds a new map using the specified key mapping.
//
// Unspecified keys will be unaltered.
// This method requires that the wrapped object be a map[string]interface{}
func (m Map) TransformKeys(mapping map[string]string) Map {
return m.Transform(func(key string, value interface{}) (string, interface{}) {
if newKey, ok := mapping[key]; ok {
return newKey, value
}
return key, value
})
}
golang-objx-0.0~git20150928.0.1a9d0bb/mutations_test.go 0000664 0000000 0000000 00000003164 12602230340 0022201 0 ustar 00root root 0000000 0000000 package objx
import (
"github.com/stretchr/testify/assert"
"testing"
)
func TestExclude(t *testing.T) {
d := make(Map)
d["name"] = "Mat"
d["age"] = 29
d["secret"] = "ABC"
excluded := d.Exclude([]string{"secret"})
assert.Equal(t, d["name"], excluded["name"])
assert.Equal(t, d["age"], excluded["age"])
assert.False(t, excluded.Has("secret"), "secret should be excluded")
}
func TestCopy(t *testing.T) {
d1 := make(map[string]interface{})
d1["name"] = "Tyler"
d1["location"] = "UT"
d1Obj := New(d1)
d2Obj := d1Obj.Copy()
d2Obj["name"] = "Mat"
assert.Equal(t, d1Obj.Get("name").Str(), "Tyler")
assert.Equal(t, d2Obj.Get("name").Str(), "Mat")
}
func TestMerge(t *testing.T) {
d := make(map[string]interface{})
d["name"] = "Mat"
d1 := make(map[string]interface{})
d1["name"] = "Tyler"
d1["location"] = "UT"
dObj := New(d)
d1Obj := New(d1)
merged := dObj.Merge(d1Obj)
assert.Equal(t, merged.Get("name").Str(), d1Obj.Get("name").Str())
assert.Equal(t, merged.Get("location").Str(), d1Obj.Get("location").Str())
assert.Empty(t, dObj.Get("location").Str())
}
func TestMergeHere(t *testing.T) {
d := make(map[string]interface{})
d["name"] = "Mat"
d1 := make(map[string]interface{})
d1["name"] = "Tyler"
d1["location"] = "UT"
dObj := New(d)
d1Obj := New(d1)
merged := dObj.MergeHere(d1Obj)
assert.Equal(t, dObj, merged, "With MergeHere, it should return the first modified map")
assert.Equal(t, merged.Get("name").Str(), d1Obj.Get("name").Str())
assert.Equal(t, merged.Get("location").Str(), d1Obj.Get("location").Str())
assert.Equal(t, merged.Get("location").Str(), dObj.Get("location").Str())
}
golang-objx-0.0~git20150928.0.1a9d0bb/security.go 0000664 0000000 0000000 00000000421 12602230340 0020757 0 ustar 00root root 0000000 0000000 package objx
import (
"crypto/sha1"
"encoding/hex"
)
// HashWithKey hashes the specified string using the security
// key.
func HashWithKey(data, key string) string {
hash := sha1.New()
hash.Write([]byte(data + ":" + key))
return hex.EncodeToString(hash.Sum(nil))
}
golang-objx-0.0~git20150928.0.1a9d0bb/security_test.go 0000664 0000000 0000000 00000000314 12602230340 0022017 0 ustar 00root root 0000000 0000000 package objx
import (
"github.com/stretchr/testify/assert"
"testing"
)
func TestHashWithKey(t *testing.T) {
assert.Equal(t, "0ce84d8d01f2c7b6e0882b784429c54d280ea2d9", HashWithKey("abc", "def"))
}
golang-objx-0.0~git20150928.0.1a9d0bb/simple_example_test.go 0000664 0000000 0000000 00000002055 12602230340 0023160 0 ustar 00root root 0000000 0000000 package objx
import (
"github.com/stretchr/testify/assert"
"testing"
)
func TestSimpleExample(t *testing.T) {
// build a map from a JSON object
o := MustFromJSON(`{"name":"Mat","foods":["indian","chinese"], "location":{"county":"hobbiton","city":"the shire"}}`)
// Map can be used as a straight map[string]interface{}
assert.Equal(t, o["name"], "Mat")
// Get an Value object
v := o.Get("name")
assert.Equal(t, v, &Value{data: "Mat"})
// Test the contained value
assert.False(t, v.IsInt())
assert.False(t, v.IsBool())
assert.True(t, v.IsStr())
// Get the contained value
assert.Equal(t, v.Str(), "Mat")
// Get a default value if the contained value is not of the expected type or does not exist
assert.Equal(t, 1, v.Int(1))
// Get a value by using array notation
assert.Equal(t, "indian", o.Get("foods[0]").Data())
// Set a value by using array notation
o.Set("foods[0]", "italian")
assert.Equal(t, "italian", o.Get("foods[0]").Str())
// Get a value by using dot notation
assert.Equal(t, "hobbiton", o.Get("location.county").Str())
}
golang-objx-0.0~git20150928.0.1a9d0bb/tests.go 0000664 0000000 0000000 00000000552 12602230340 0020257 0 ustar 00root root 0000000 0000000 package objx
// Has gets whether there is something at the specified selector
// or not.
//
// If m is nil, Has will always return false.
func (m Map) Has(selector string) bool {
if m == nil {
return false
}
return !m.Get(selector).IsNil()
}
// IsNil gets whether the data is nil or not.
func (v *Value) IsNil() bool {
return v == nil || v.data == nil
}
golang-objx-0.0~git20150928.0.1a9d0bb/tests_test.go 0000664 0000000 0000000 00000000666 12602230340 0021324 0 ustar 00root root 0000000 0000000 package objx
import (
"github.com/stretchr/testify/assert"
"testing"
)
func TestHas(t *testing.T) {
m := New(TestMap)
assert.True(t, m.Has("name"))
assert.True(t, m.Has("address.state"))
assert.True(t, m.Has("numbers[4]"))
assert.False(t, m.Has("address.state.nope"))
assert.False(t, m.Has("address.nope"))
assert.False(t, m.Has("nope"))
assert.False(t, m.Has("numbers[5]"))
m = nil
assert.False(t, m.Has("nothing"))
}
golang-objx-0.0~git20150928.0.1a9d0bb/type_specific_codegen.go 0000664 0000000 0000000 00000216146 12602230340 0023437 0 ustar 00root root 0000000 0000000 package objx
/*
Inter (interface{} and []interface{})
--------------------------------------------------
*/
// Inter gets the value as a interface{}, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Inter(optionalDefault ...interface{}) interface{} {
if s, ok := v.data.(interface{}); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustInter gets the value as a interface{}.
//
// Panics if the object is not a interface{}.
func (v *Value) MustInter() interface{} {
return v.data.(interface{})
}
// InterSlice gets the value as a []interface{}, returns the optionalDefault
// value or nil if the value is not a []interface{}.
func (v *Value) InterSlice(optionalDefault ...[]interface{}) []interface{} {
if s, ok := v.data.([]interface{}); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustInterSlice gets the value as a []interface{}.
//
// Panics if the object is not a []interface{}.
func (v *Value) MustInterSlice() []interface{} {
return v.data.([]interface{})
}
// IsInter gets whether the object contained is a interface{} or not.
func (v *Value) IsInter() bool {
_, ok := v.data.(interface{})
return ok
}
// IsInterSlice gets whether the object contained is a []interface{} or not.
func (v *Value) IsInterSlice() bool {
_, ok := v.data.([]interface{})
return ok
}
// EachInter calls the specified callback for each object
// in the []interface{}.
//
// Panics if the object is the wrong type.
func (v *Value) EachInter(callback func(int, interface{}) bool) *Value {
for index, val := range v.MustInterSlice() {
carryon := callback(index, val)
if carryon == false {
break
}
}
return v
}
// WhereInter uses the specified decider function to select items
// from the []interface{}. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereInter(decider func(int, interface{}) bool) *Value {
var selected []interface{}
v.EachInter(func(index int, val interface{}) bool {
shouldSelect := decider(index, val)
if shouldSelect == false {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupInter uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]interface{}.
func (v *Value) GroupInter(grouper func(int, interface{}) string) *Value {
groups := make(map[string][]interface{})
v.EachInter(func(index int, val interface{}) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]interface{}, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceInter uses the specified function to replace each interface{}s
// by iterating each item. The data in the returned result will be a
// []interface{} containing the replaced items.
func (v *Value) ReplaceInter(replacer func(int, interface{}) interface{}) *Value {
arr := v.MustInterSlice()
replaced := make([]interface{}, len(arr))
v.EachInter(func(index int, val interface{}) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectInter uses the specified collector function to collect a value
// for each of the interface{}s in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectInter(collector func(int, interface{}) interface{}) *Value {
arr := v.MustInterSlice()
collected := make([]interface{}, len(arr))
v.EachInter(func(index int, val interface{}) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
MSI (map[string]interface{} and []map[string]interface{})
--------------------------------------------------
*/
// MSI gets the value as a map[string]interface{}, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) MSI(optionalDefault ...map[string]interface{}) map[string]interface{} {
if s, ok := v.data.(map[string]interface{}); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustMSI gets the value as a map[string]interface{}.
//
// Panics if the object is not a map[string]interface{}.
func (v *Value) MustMSI() map[string]interface{} {
return v.data.(map[string]interface{})
}
// MSISlice gets the value as a []map[string]interface{}, returns the optionalDefault
// value or nil if the value is not a []map[string]interface{}.
func (v *Value) MSISlice(optionalDefault ...[]map[string]interface{}) []map[string]interface{} {
if s, ok := v.data.([]map[string]interface{}); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustMSISlice gets the value as a []map[string]interface{}.
//
// Panics if the object is not a []map[string]interface{}.
func (v *Value) MustMSISlice() []map[string]interface{} {
return v.data.([]map[string]interface{})
}
// IsMSI gets whether the object contained is a map[string]interface{} or not.
func (v *Value) IsMSI() bool {
_, ok := v.data.(map[string]interface{})
return ok
}
// IsMSISlice gets whether the object contained is a []map[string]interface{} or not.
func (v *Value) IsMSISlice() bool {
_, ok := v.data.([]map[string]interface{})
return ok
}
// EachMSI calls the specified callback for each object
// in the []map[string]interface{}.
//
// Panics if the object is the wrong type.
func (v *Value) EachMSI(callback func(int, map[string]interface{}) bool) *Value {
for index, val := range v.MustMSISlice() {
carryon := callback(index, val)
if carryon == false {
break
}
}
return v
}
// WhereMSI uses the specified decider function to select items
// from the []map[string]interface{}. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereMSI(decider func(int, map[string]interface{}) bool) *Value {
var selected []map[string]interface{}
v.EachMSI(func(index int, val map[string]interface{}) bool {
shouldSelect := decider(index, val)
if shouldSelect == false {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupMSI uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]map[string]interface{}.
func (v *Value) GroupMSI(grouper func(int, map[string]interface{}) string) *Value {
groups := make(map[string][]map[string]interface{})
v.EachMSI(func(index int, val map[string]interface{}) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]map[string]interface{}, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceMSI uses the specified function to replace each map[string]interface{}s
// by iterating each item. The data in the returned result will be a
// []map[string]interface{} containing the replaced items.
func (v *Value) ReplaceMSI(replacer func(int, map[string]interface{}) map[string]interface{}) *Value {
arr := v.MustMSISlice()
replaced := make([]map[string]interface{}, len(arr))
v.EachMSI(func(index int, val map[string]interface{}) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectMSI uses the specified collector function to collect a value
// for each of the map[string]interface{}s in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectMSI(collector func(int, map[string]interface{}) interface{}) *Value {
arr := v.MustMSISlice()
collected := make([]interface{}, len(arr))
v.EachMSI(func(index int, val map[string]interface{}) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
ObjxMap ((Map) and [](Map))
--------------------------------------------------
*/
// ObjxMap gets the value as a (Map), returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) ObjxMap(optionalDefault ...(Map)) Map {
if s, ok := v.data.((Map)); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return New(nil)
}
// MustObjxMap gets the value as a (Map).
//
// Panics if the object is not a (Map).
func (v *Value) MustObjxMap() Map {
return v.data.((Map))
}
// ObjxMapSlice gets the value as a [](Map), returns the optionalDefault
// value or nil if the value is not a [](Map).
func (v *Value) ObjxMapSlice(optionalDefault ...[](Map)) [](Map) {
if s, ok := v.data.([](Map)); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustObjxMapSlice gets the value as a [](Map).
//
// Panics if the object is not a [](Map).
func (v *Value) MustObjxMapSlice() [](Map) {
return v.data.([](Map))
}
// IsObjxMap gets whether the object contained is a (Map) or not.
func (v *Value) IsObjxMap() bool {
_, ok := v.data.((Map))
return ok
}
// IsObjxMapSlice gets whether the object contained is a [](Map) or not.
func (v *Value) IsObjxMapSlice() bool {
_, ok := v.data.([](Map))
return ok
}
// EachObjxMap calls the specified callback for each object
// in the [](Map).
//
// Panics if the object is the wrong type.
func (v *Value) EachObjxMap(callback func(int, Map) bool) *Value {
for index, val := range v.MustObjxMapSlice() {
carryon := callback(index, val)
if carryon == false {
break
}
}
return v
}
// WhereObjxMap uses the specified decider function to select items
// from the [](Map). The object contained in the result will contain
// only the selected items.
func (v *Value) WhereObjxMap(decider func(int, Map) bool) *Value {
var selected [](Map)
v.EachObjxMap(func(index int, val Map) bool {
shouldSelect := decider(index, val)
if shouldSelect == false {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupObjxMap uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][](Map).
func (v *Value) GroupObjxMap(grouper func(int, Map) string) *Value {
groups := make(map[string][](Map))
v.EachObjxMap(func(index int, val Map) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([](Map), 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceObjxMap uses the specified function to replace each (Map)s
// by iterating each item. The data in the returned result will be a
// [](Map) containing the replaced items.
func (v *Value) ReplaceObjxMap(replacer func(int, Map) Map) *Value {
arr := v.MustObjxMapSlice()
replaced := make([](Map), len(arr))
v.EachObjxMap(func(index int, val Map) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectObjxMap uses the specified collector function to collect a value
// for each of the (Map)s in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectObjxMap(collector func(int, Map) interface{}) *Value {
arr := v.MustObjxMapSlice()
collected := make([]interface{}, len(arr))
v.EachObjxMap(func(index int, val Map) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Bool (bool and []bool)
--------------------------------------------------
*/
// Bool gets the value as a bool, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Bool(optionalDefault ...bool) bool {
if s, ok := v.data.(bool); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return false
}
// MustBool gets the value as a bool.
//
// Panics if the object is not a bool.
func (v *Value) MustBool() bool {
return v.data.(bool)
}
// BoolSlice gets the value as a []bool, returns the optionalDefault
// value or nil if the value is not a []bool.
func (v *Value) BoolSlice(optionalDefault ...[]bool) []bool {
if s, ok := v.data.([]bool); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustBoolSlice gets the value as a []bool.
//
// Panics if the object is not a []bool.
func (v *Value) MustBoolSlice() []bool {
return v.data.([]bool)
}
// IsBool gets whether the object contained is a bool or not.
func (v *Value) IsBool() bool {
_, ok := v.data.(bool)
return ok
}
// IsBoolSlice gets whether the object contained is a []bool or not.
func (v *Value) IsBoolSlice() bool {
_, ok := v.data.([]bool)
return ok
}
// EachBool calls the specified callback for each object
// in the []bool.
//
// Panics if the object is the wrong type.
func (v *Value) EachBool(callback func(int, bool) bool) *Value {
for index, val := range v.MustBoolSlice() {
carryon := callback(index, val)
if carryon == false {
break
}
}
return v
}
// WhereBool uses the specified decider function to select items
// from the []bool. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereBool(decider func(int, bool) bool) *Value {
var selected []bool
v.EachBool(func(index int, val bool) bool {
shouldSelect := decider(index, val)
if shouldSelect == false {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupBool uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]bool.
func (v *Value) GroupBool(grouper func(int, bool) string) *Value {
groups := make(map[string][]bool)
v.EachBool(func(index int, val bool) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]bool, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceBool uses the specified function to replace each bools
// by iterating each item. The data in the returned result will be a
// []bool containing the replaced items.
func (v *Value) ReplaceBool(replacer func(int, bool) bool) *Value {
arr := v.MustBoolSlice()
replaced := make([]bool, len(arr))
v.EachBool(func(index int, val bool) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectBool uses the specified collector function to collect a value
// for each of the bools in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectBool(collector func(int, bool) interface{}) *Value {
arr := v.MustBoolSlice()
collected := make([]interface{}, len(arr))
v.EachBool(func(index int, val bool) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Str (string and []string)
--------------------------------------------------
*/
// Str gets the value as a string, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Str(optionalDefault ...string) string {
if s, ok := v.data.(string); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return ""
}
// MustStr gets the value as a string.
//
// Panics if the object is not a string.
func (v *Value) MustStr() string {
return v.data.(string)
}
// StrSlice gets the value as a []string, returns the optionalDefault
// value or nil if the value is not a []string.
func (v *Value) StrSlice(optionalDefault ...[]string) []string {
if s, ok := v.data.([]string); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustStrSlice gets the value as a []string.
//
// Panics if the object is not a []string.
func (v *Value) MustStrSlice() []string {
return v.data.([]string)
}
// IsStr gets whether the object contained is a string or not.
func (v *Value) IsStr() bool {
_, ok := v.data.(string)
return ok
}
// IsStrSlice gets whether the object contained is a []string or not.
func (v *Value) IsStrSlice() bool {
_, ok := v.data.([]string)
return ok
}
// EachStr calls the specified callback for each object
// in the []string.
//
// Panics if the object is the wrong type.
func (v *Value) EachStr(callback func(int, string) bool) *Value {
for index, val := range v.MustStrSlice() {
carryon := callback(index, val)
if carryon == false {
break
}
}
return v
}
// WhereStr uses the specified decider function to select items
// from the []string. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereStr(decider func(int, string) bool) *Value {
var selected []string
v.EachStr(func(index int, val string) bool {
shouldSelect := decider(index, val)
if shouldSelect == false {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupStr uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]string.
func (v *Value) GroupStr(grouper func(int, string) string) *Value {
groups := make(map[string][]string)
v.EachStr(func(index int, val string) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]string, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceStr uses the specified function to replace each strings
// by iterating each item. The data in the returned result will be a
// []string containing the replaced items.
func (v *Value) ReplaceStr(replacer func(int, string) string) *Value {
arr := v.MustStrSlice()
replaced := make([]string, len(arr))
v.EachStr(func(index int, val string) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectStr uses the specified collector function to collect a value
// for each of the strings in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectStr(collector func(int, string) interface{}) *Value {
arr := v.MustStrSlice()
collected := make([]interface{}, len(arr))
v.EachStr(func(index int, val string) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Int (int and []int)
--------------------------------------------------
*/
// Int gets the value as a int, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Int(optionalDefault ...int) int {
if s, ok := v.data.(int); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return 0
}
// MustInt gets the value as a int.
//
// Panics if the object is not a int.
func (v *Value) MustInt() int {
return v.data.(int)
}
// IntSlice gets the value as a []int, returns the optionalDefault
// value or nil if the value is not a []int.
func (v *Value) IntSlice(optionalDefault ...[]int) []int {
if s, ok := v.data.([]int); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustIntSlice gets the value as a []int.
//
// Panics if the object is not a []int.
func (v *Value) MustIntSlice() []int {
return v.data.([]int)
}
// IsInt gets whether the object contained is a int or not.
func (v *Value) IsInt() bool {
_, ok := v.data.(int)
return ok
}
// IsIntSlice gets whether the object contained is a []int or not.
func (v *Value) IsIntSlice() bool {
_, ok := v.data.([]int)
return ok
}
// EachInt calls the specified callback for each object
// in the []int.
//
// Panics if the object is the wrong type.
func (v *Value) EachInt(callback func(int, int) bool) *Value {
for index, val := range v.MustIntSlice() {
carryon := callback(index, val)
if carryon == false {
break
}
}
return v
}
// WhereInt uses the specified decider function to select items
// from the []int. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereInt(decider func(int, int) bool) *Value {
var selected []int
v.EachInt(func(index int, val int) bool {
shouldSelect := decider(index, val)
if shouldSelect == false {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupInt uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]int.
func (v *Value) GroupInt(grouper func(int, int) string) *Value {
groups := make(map[string][]int)
v.EachInt(func(index int, val int) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]int, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceInt uses the specified function to replace each ints
// by iterating each item. The data in the returned result will be a
// []int containing the replaced items.
func (v *Value) ReplaceInt(replacer func(int, int) int) *Value {
arr := v.MustIntSlice()
replaced := make([]int, len(arr))
v.EachInt(func(index int, val int) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectInt uses the specified collector function to collect a value
// for each of the ints in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectInt(collector func(int, int) interface{}) *Value {
arr := v.MustIntSlice()
collected := make([]interface{}, len(arr))
v.EachInt(func(index int, val int) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Int8 (int8 and []int8)
--------------------------------------------------
*/
// Int8 gets the value as a int8, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Int8(optionalDefault ...int8) int8 {
if s, ok := v.data.(int8); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return 0
}
// MustInt8 gets the value as a int8.
//
// Panics if the object is not a int8.
func (v *Value) MustInt8() int8 {
return v.data.(int8)
}
// Int8Slice gets the value as a []int8, returns the optionalDefault
// value or nil if the value is not a []int8.
func (v *Value) Int8Slice(optionalDefault ...[]int8) []int8 {
if s, ok := v.data.([]int8); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustInt8Slice gets the value as a []int8.
//
// Panics if the object is not a []int8.
func (v *Value) MustInt8Slice() []int8 {
return v.data.([]int8)
}
// IsInt8 gets whether the object contained is a int8 or not.
func (v *Value) IsInt8() bool {
_, ok := v.data.(int8)
return ok
}
// IsInt8Slice gets whether the object contained is a []int8 or not.
func (v *Value) IsInt8Slice() bool {
_, ok := v.data.([]int8)
return ok
}
// EachInt8 calls the specified callback for each object
// in the []int8.
//
// Panics if the object is the wrong type.
func (v *Value) EachInt8(callback func(int, int8) bool) *Value {
for index, val := range v.MustInt8Slice() {
carryon := callback(index, val)
if carryon == false {
break
}
}
return v
}
// WhereInt8 uses the specified decider function to select items
// from the []int8. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereInt8(decider func(int, int8) bool) *Value {
var selected []int8
v.EachInt8(func(index int, val int8) bool {
shouldSelect := decider(index, val)
if shouldSelect == false {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupInt8 uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]int8.
func (v *Value) GroupInt8(grouper func(int, int8) string) *Value {
groups := make(map[string][]int8)
v.EachInt8(func(index int, val int8) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]int8, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceInt8 uses the specified function to replace each int8s
// by iterating each item. The data in the returned result will be a
// []int8 containing the replaced items.
func (v *Value) ReplaceInt8(replacer func(int, int8) int8) *Value {
arr := v.MustInt8Slice()
replaced := make([]int8, len(arr))
v.EachInt8(func(index int, val int8) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectInt8 uses the specified collector function to collect a value
// for each of the int8s in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectInt8(collector func(int, int8) interface{}) *Value {
arr := v.MustInt8Slice()
collected := make([]interface{}, len(arr))
v.EachInt8(func(index int, val int8) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Int16 (int16 and []int16)
--------------------------------------------------
*/
// Int16 gets the value as a int16, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Int16(optionalDefault ...int16) int16 {
if s, ok := v.data.(int16); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return 0
}
// MustInt16 gets the value as a int16.
//
// Panics if the object is not a int16.
func (v *Value) MustInt16() int16 {
return v.data.(int16)
}
// Int16Slice gets the value as a []int16, returns the optionalDefault
// value or nil if the value is not a []int16.
func (v *Value) Int16Slice(optionalDefault ...[]int16) []int16 {
if s, ok := v.data.([]int16); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustInt16Slice gets the value as a []int16.
//
// Panics if the object is not a []int16.
func (v *Value) MustInt16Slice() []int16 {
return v.data.([]int16)
}
// IsInt16 gets whether the object contained is a int16 or not.
func (v *Value) IsInt16() bool {
_, ok := v.data.(int16)
return ok
}
// IsInt16Slice gets whether the object contained is a []int16 or not.
func (v *Value) IsInt16Slice() bool {
_, ok := v.data.([]int16)
return ok
}
// EachInt16 calls the specified callback for each object
// in the []int16.
//
// Panics if the object is the wrong type.
func (v *Value) EachInt16(callback func(int, int16) bool) *Value {
for index, val := range v.MustInt16Slice() {
carryon := callback(index, val)
if carryon == false {
break
}
}
return v
}
// WhereInt16 uses the specified decider function to select items
// from the []int16. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereInt16(decider func(int, int16) bool) *Value {
var selected []int16
v.EachInt16(func(index int, val int16) bool {
shouldSelect := decider(index, val)
if shouldSelect == false {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupInt16 uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]int16.
func (v *Value) GroupInt16(grouper func(int, int16) string) *Value {
groups := make(map[string][]int16)
v.EachInt16(func(index int, val int16) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]int16, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceInt16 uses the specified function to replace each int16s
// by iterating each item. The data in the returned result will be a
// []int16 containing the replaced items.
func (v *Value) ReplaceInt16(replacer func(int, int16) int16) *Value {
arr := v.MustInt16Slice()
replaced := make([]int16, len(arr))
v.EachInt16(func(index int, val int16) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectInt16 uses the specified collector function to collect a value
// for each of the int16s in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectInt16(collector func(int, int16) interface{}) *Value {
arr := v.MustInt16Slice()
collected := make([]interface{}, len(arr))
v.EachInt16(func(index int, val int16) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Int32 (int32 and []int32)
--------------------------------------------------
*/
// Int32 gets the value as a int32, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Int32(optionalDefault ...int32) int32 {
if s, ok := v.data.(int32); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return 0
}
// MustInt32 gets the value as a int32.
//
// Panics if the object is not a int32.
func (v *Value) MustInt32() int32 {
return v.data.(int32)
}
// Int32Slice gets the value as a []int32, returns the optionalDefault
// value or nil if the value is not a []int32.
func (v *Value) Int32Slice(optionalDefault ...[]int32) []int32 {
if s, ok := v.data.([]int32); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustInt32Slice gets the value as a []int32.
//
// Panics if the object is not a []int32.
func (v *Value) MustInt32Slice() []int32 {
return v.data.([]int32)
}
// IsInt32 gets whether the object contained is a int32 or not.
func (v *Value) IsInt32() bool {
_, ok := v.data.(int32)
return ok
}
// IsInt32Slice gets whether the object contained is a []int32 or not.
func (v *Value) IsInt32Slice() bool {
_, ok := v.data.([]int32)
return ok
}
// EachInt32 calls the specified callback for each object
// in the []int32.
//
// Panics if the object is the wrong type.
func (v *Value) EachInt32(callback func(int, int32) bool) *Value {
for index, val := range v.MustInt32Slice() {
carryon := callback(index, val)
if carryon == false {
break
}
}
return v
}
// WhereInt32 uses the specified decider function to select items
// from the []int32. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereInt32(decider func(int, int32) bool) *Value {
var selected []int32
v.EachInt32(func(index int, val int32) bool {
shouldSelect := decider(index, val)
if shouldSelect == false {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupInt32 uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]int32.
func (v *Value) GroupInt32(grouper func(int, int32) string) *Value {
groups := make(map[string][]int32)
v.EachInt32(func(index int, val int32) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]int32, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceInt32 uses the specified function to replace each int32s
// by iterating each item. The data in the returned result will be a
// []int32 containing the replaced items.
func (v *Value) ReplaceInt32(replacer func(int, int32) int32) *Value {
arr := v.MustInt32Slice()
replaced := make([]int32, len(arr))
v.EachInt32(func(index int, val int32) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectInt32 uses the specified collector function to collect a value
// for each of the int32s in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectInt32(collector func(int, int32) interface{}) *Value {
arr := v.MustInt32Slice()
collected := make([]interface{}, len(arr))
v.EachInt32(func(index int, val int32) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Int64 (int64 and []int64)
--------------------------------------------------
*/
// Int64 gets the value as a int64, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Int64(optionalDefault ...int64) int64 {
if s, ok := v.data.(int64); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return 0
}
// MustInt64 gets the value as a int64.
//
// Panics if the object is not a int64.
func (v *Value) MustInt64() int64 {
return v.data.(int64)
}
// Int64Slice gets the value as a []int64, returns the optionalDefault
// value or nil if the value is not a []int64.
func (v *Value) Int64Slice(optionalDefault ...[]int64) []int64 {
if s, ok := v.data.([]int64); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustInt64Slice gets the value as a []int64.
//
// Panics if the object is not a []int64.
func (v *Value) MustInt64Slice() []int64 {
return v.data.([]int64)
}
// IsInt64 gets whether the object contained is a int64 or not.
func (v *Value) IsInt64() bool {
_, ok := v.data.(int64)
return ok
}
// IsInt64Slice gets whether the object contained is a []int64 or not.
func (v *Value) IsInt64Slice() bool {
_, ok := v.data.([]int64)
return ok
}
// EachInt64 calls the specified callback for each object
// in the []int64.
//
// Panics if the object is the wrong type.
func (v *Value) EachInt64(callback func(int, int64) bool) *Value {
for index, val := range v.MustInt64Slice() {
carryon := callback(index, val)
if carryon == false {
break
}
}
return v
}
// WhereInt64 uses the specified decider function to select items
// from the []int64. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereInt64(decider func(int, int64) bool) *Value {
var selected []int64
v.EachInt64(func(index int, val int64) bool {
shouldSelect := decider(index, val)
if shouldSelect == false {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupInt64 uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]int64.
func (v *Value) GroupInt64(grouper func(int, int64) string) *Value {
groups := make(map[string][]int64)
v.EachInt64(func(index int, val int64) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]int64, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceInt64 uses the specified function to replace each int64s
// by iterating each item. The data in the returned result will be a
// []int64 containing the replaced items.
func (v *Value) ReplaceInt64(replacer func(int, int64) int64) *Value {
arr := v.MustInt64Slice()
replaced := make([]int64, len(arr))
v.EachInt64(func(index int, val int64) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectInt64 uses the specified collector function to collect a value
// for each of the int64s in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectInt64(collector func(int, int64) interface{}) *Value {
arr := v.MustInt64Slice()
collected := make([]interface{}, len(arr))
v.EachInt64(func(index int, val int64) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Uint (uint and []uint)
--------------------------------------------------
*/
// Uint gets the value as a uint, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Uint(optionalDefault ...uint) uint {
if s, ok := v.data.(uint); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return 0
}
// MustUint gets the value as a uint.
//
// Panics if the object is not a uint.
func (v *Value) MustUint() uint {
return v.data.(uint)
}
// UintSlice gets the value as a []uint, returns the optionalDefault
// value or nil if the value is not a []uint.
func (v *Value) UintSlice(optionalDefault ...[]uint) []uint {
if s, ok := v.data.([]uint); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustUintSlice gets the value as a []uint.
//
// Panics if the object is not a []uint.
func (v *Value) MustUintSlice() []uint {
return v.data.([]uint)
}
// IsUint gets whether the object contained is a uint or not.
func (v *Value) IsUint() bool {
_, ok := v.data.(uint)
return ok
}
// IsUintSlice gets whether the object contained is a []uint or not.
func (v *Value) IsUintSlice() bool {
_, ok := v.data.([]uint)
return ok
}
// EachUint calls the specified callback for each object
// in the []uint.
//
// Panics if the object is the wrong type.
func (v *Value) EachUint(callback func(int, uint) bool) *Value {
for index, val := range v.MustUintSlice() {
carryon := callback(index, val)
if carryon == false {
break
}
}
return v
}
// WhereUint uses the specified decider function to select items
// from the []uint. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereUint(decider func(int, uint) bool) *Value {
var selected []uint
v.EachUint(func(index int, val uint) bool {
shouldSelect := decider(index, val)
if shouldSelect == false {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupUint uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]uint.
func (v *Value) GroupUint(grouper func(int, uint) string) *Value {
groups := make(map[string][]uint)
v.EachUint(func(index int, val uint) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]uint, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceUint uses the specified function to replace each uints
// by iterating each item. The data in the returned result will be a
// []uint containing the replaced items.
func (v *Value) ReplaceUint(replacer func(int, uint) uint) *Value {
arr := v.MustUintSlice()
replaced := make([]uint, len(arr))
v.EachUint(func(index int, val uint) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectUint uses the specified collector function to collect a value
// for each of the uints in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectUint(collector func(int, uint) interface{}) *Value {
arr := v.MustUintSlice()
collected := make([]interface{}, len(arr))
v.EachUint(func(index int, val uint) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Uint8 (uint8 and []uint8)
--------------------------------------------------
*/
// Uint8 gets the value as a uint8, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Uint8(optionalDefault ...uint8) uint8 {
if s, ok := v.data.(uint8); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return 0
}
// MustUint8 gets the value as a uint8.
//
// Panics if the object is not a uint8.
func (v *Value) MustUint8() uint8 {
return v.data.(uint8)
}
// Uint8Slice gets the value as a []uint8, returns the optionalDefault
// value or nil if the value is not a []uint8.
func (v *Value) Uint8Slice(optionalDefault ...[]uint8) []uint8 {
if s, ok := v.data.([]uint8); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustUint8Slice gets the value as a []uint8.
//
// Panics if the object is not a []uint8.
func (v *Value) MustUint8Slice() []uint8 {
return v.data.([]uint8)
}
// IsUint8 gets whether the object contained is a uint8 or not.
func (v *Value) IsUint8() bool {
_, ok := v.data.(uint8)
return ok
}
// IsUint8Slice gets whether the object contained is a []uint8 or not.
func (v *Value) IsUint8Slice() bool {
_, ok := v.data.([]uint8)
return ok
}
// EachUint8 calls the specified callback for each object
// in the []uint8.
//
// Panics if the object is the wrong type.
func (v *Value) EachUint8(callback func(int, uint8) bool) *Value {
for index, val := range v.MustUint8Slice() {
carryon := callback(index, val)
if carryon == false {
break
}
}
return v
}
// WhereUint8 uses the specified decider function to select items
// from the []uint8. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereUint8(decider func(int, uint8) bool) *Value {
var selected []uint8
v.EachUint8(func(index int, val uint8) bool {
shouldSelect := decider(index, val)
if shouldSelect == false {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupUint8 uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]uint8.
func (v *Value) GroupUint8(grouper func(int, uint8) string) *Value {
groups := make(map[string][]uint8)
v.EachUint8(func(index int, val uint8) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]uint8, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceUint8 uses the specified function to replace each uint8s
// by iterating each item. The data in the returned result will be a
// []uint8 containing the replaced items.
func (v *Value) ReplaceUint8(replacer func(int, uint8) uint8) *Value {
arr := v.MustUint8Slice()
replaced := make([]uint8, len(arr))
v.EachUint8(func(index int, val uint8) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectUint8 uses the specified collector function to collect a value
// for each of the uint8s in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectUint8(collector func(int, uint8) interface{}) *Value {
arr := v.MustUint8Slice()
collected := make([]interface{}, len(arr))
v.EachUint8(func(index int, val uint8) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Uint16 (uint16 and []uint16)
--------------------------------------------------
*/
// Uint16 gets the value as a uint16, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Uint16(optionalDefault ...uint16) uint16 {
if s, ok := v.data.(uint16); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return 0
}
// MustUint16 gets the value as a uint16.
//
// Panics if the object is not a uint16.
func (v *Value) MustUint16() uint16 {
return v.data.(uint16)
}
// Uint16Slice gets the value as a []uint16, returns the optionalDefault
// value or nil if the value is not a []uint16.
func (v *Value) Uint16Slice(optionalDefault ...[]uint16) []uint16 {
if s, ok := v.data.([]uint16); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustUint16Slice gets the value as a []uint16.
//
// Panics if the object is not a []uint16.
func (v *Value) MustUint16Slice() []uint16 {
return v.data.([]uint16)
}
// IsUint16 gets whether the object contained is a uint16 or not.
func (v *Value) IsUint16() bool {
_, ok := v.data.(uint16)
return ok
}
// IsUint16Slice gets whether the object contained is a []uint16 or not.
func (v *Value) IsUint16Slice() bool {
_, ok := v.data.([]uint16)
return ok
}
// EachUint16 calls the specified callback for each object
// in the []uint16.
//
// Panics if the object is the wrong type.
func (v *Value) EachUint16(callback func(int, uint16) bool) *Value {
for index, val := range v.MustUint16Slice() {
carryon := callback(index, val)
if carryon == false {
break
}
}
return v
}
// WhereUint16 uses the specified decider function to select items
// from the []uint16. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereUint16(decider func(int, uint16) bool) *Value {
var selected []uint16
v.EachUint16(func(index int, val uint16) bool {
shouldSelect := decider(index, val)
if shouldSelect == false {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupUint16 uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]uint16.
func (v *Value) GroupUint16(grouper func(int, uint16) string) *Value {
groups := make(map[string][]uint16)
v.EachUint16(func(index int, val uint16) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]uint16, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceUint16 uses the specified function to replace each uint16s
// by iterating each item. The data in the returned result will be a
// []uint16 containing the replaced items.
func (v *Value) ReplaceUint16(replacer func(int, uint16) uint16) *Value {
arr := v.MustUint16Slice()
replaced := make([]uint16, len(arr))
v.EachUint16(func(index int, val uint16) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectUint16 uses the specified collector function to collect a value
// for each of the uint16s in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectUint16(collector func(int, uint16) interface{}) *Value {
arr := v.MustUint16Slice()
collected := make([]interface{}, len(arr))
v.EachUint16(func(index int, val uint16) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Uint32 (uint32 and []uint32)
--------------------------------------------------
*/
// Uint32 gets the value as a uint32, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Uint32(optionalDefault ...uint32) uint32 {
if s, ok := v.data.(uint32); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return 0
}
// MustUint32 gets the value as a uint32.
//
// Panics if the object is not a uint32.
func (v *Value) MustUint32() uint32 {
return v.data.(uint32)
}
// Uint32Slice gets the value as a []uint32, returns the optionalDefault
// value or nil if the value is not a []uint32.
func (v *Value) Uint32Slice(optionalDefault ...[]uint32) []uint32 {
if s, ok := v.data.([]uint32); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustUint32Slice gets the value as a []uint32.
//
// Panics if the object is not a []uint32.
func (v *Value) MustUint32Slice() []uint32 {
return v.data.([]uint32)
}
// IsUint32 gets whether the object contained is a uint32 or not.
func (v *Value) IsUint32() bool {
_, ok := v.data.(uint32)
return ok
}
// IsUint32Slice gets whether the object contained is a []uint32 or not.
func (v *Value) IsUint32Slice() bool {
_, ok := v.data.([]uint32)
return ok
}
// EachUint32 calls the specified callback for each object
// in the []uint32.
//
// Panics if the object is the wrong type.
func (v *Value) EachUint32(callback func(int, uint32) bool) *Value {
for index, val := range v.MustUint32Slice() {
carryon := callback(index, val)
if carryon == false {
break
}
}
return v
}
// WhereUint32 uses the specified decider function to select items
// from the []uint32. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereUint32(decider func(int, uint32) bool) *Value {
var selected []uint32
v.EachUint32(func(index int, val uint32) bool {
shouldSelect := decider(index, val)
if shouldSelect == false {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupUint32 uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]uint32.
func (v *Value) GroupUint32(grouper func(int, uint32) string) *Value {
groups := make(map[string][]uint32)
v.EachUint32(func(index int, val uint32) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]uint32, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceUint32 uses the specified function to replace each uint32s
// by iterating each item. The data in the returned result will be a
// []uint32 containing the replaced items.
func (v *Value) ReplaceUint32(replacer func(int, uint32) uint32) *Value {
arr := v.MustUint32Slice()
replaced := make([]uint32, len(arr))
v.EachUint32(func(index int, val uint32) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectUint32 uses the specified collector function to collect a value
// for each of the uint32s in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectUint32(collector func(int, uint32) interface{}) *Value {
arr := v.MustUint32Slice()
collected := make([]interface{}, len(arr))
v.EachUint32(func(index int, val uint32) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Uint64 (uint64 and []uint64)
--------------------------------------------------
*/
// Uint64 gets the value as a uint64, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Uint64(optionalDefault ...uint64) uint64 {
if s, ok := v.data.(uint64); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return 0
}
// MustUint64 gets the value as a uint64.
//
// Panics if the object is not a uint64.
func (v *Value) MustUint64() uint64 {
return v.data.(uint64)
}
// Uint64Slice gets the value as a []uint64, returns the optionalDefault
// value or nil if the value is not a []uint64.
func (v *Value) Uint64Slice(optionalDefault ...[]uint64) []uint64 {
if s, ok := v.data.([]uint64); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustUint64Slice gets the value as a []uint64.
//
// Panics if the object is not a []uint64.
func (v *Value) MustUint64Slice() []uint64 {
return v.data.([]uint64)
}
// IsUint64 gets whether the object contained is a uint64 or not.
func (v *Value) IsUint64() bool {
_, ok := v.data.(uint64)
return ok
}
// IsUint64Slice gets whether the object contained is a []uint64 or not.
func (v *Value) IsUint64Slice() bool {
_, ok := v.data.([]uint64)
return ok
}
// EachUint64 calls the specified callback for each object
// in the []uint64.
//
// Panics if the object is the wrong type.
func (v *Value) EachUint64(callback func(int, uint64) bool) *Value {
for index, val := range v.MustUint64Slice() {
carryon := callback(index, val)
if carryon == false {
break
}
}
return v
}
// WhereUint64 uses the specified decider function to select items
// from the []uint64. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereUint64(decider func(int, uint64) bool) *Value {
var selected []uint64
v.EachUint64(func(index int, val uint64) bool {
shouldSelect := decider(index, val)
if shouldSelect == false {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupUint64 uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]uint64.
func (v *Value) GroupUint64(grouper func(int, uint64) string) *Value {
groups := make(map[string][]uint64)
v.EachUint64(func(index int, val uint64) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]uint64, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceUint64 uses the specified function to replace each uint64s
// by iterating each item. The data in the returned result will be a
// []uint64 containing the replaced items.
func (v *Value) ReplaceUint64(replacer func(int, uint64) uint64) *Value {
arr := v.MustUint64Slice()
replaced := make([]uint64, len(arr))
v.EachUint64(func(index int, val uint64) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectUint64 uses the specified collector function to collect a value
// for each of the uint64s in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectUint64(collector func(int, uint64) interface{}) *Value {
arr := v.MustUint64Slice()
collected := make([]interface{}, len(arr))
v.EachUint64(func(index int, val uint64) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Uintptr (uintptr and []uintptr)
--------------------------------------------------
*/
// Uintptr gets the value as a uintptr, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Uintptr(optionalDefault ...uintptr) uintptr {
if s, ok := v.data.(uintptr); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return 0
}
// MustUintptr gets the value as a uintptr.
//
// Panics if the object is not a uintptr.
func (v *Value) MustUintptr() uintptr {
return v.data.(uintptr)
}
// UintptrSlice gets the value as a []uintptr, returns the optionalDefault
// value or nil if the value is not a []uintptr.
func (v *Value) UintptrSlice(optionalDefault ...[]uintptr) []uintptr {
if s, ok := v.data.([]uintptr); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustUintptrSlice gets the value as a []uintptr.
//
// Panics if the object is not a []uintptr.
func (v *Value) MustUintptrSlice() []uintptr {
return v.data.([]uintptr)
}
// IsUintptr gets whether the object contained is a uintptr or not.
func (v *Value) IsUintptr() bool {
_, ok := v.data.(uintptr)
return ok
}
// IsUintptrSlice gets whether the object contained is a []uintptr or not.
func (v *Value) IsUintptrSlice() bool {
_, ok := v.data.([]uintptr)
return ok
}
// EachUintptr calls the specified callback for each object
// in the []uintptr.
//
// Panics if the object is the wrong type.
func (v *Value) EachUintptr(callback func(int, uintptr) bool) *Value {
for index, val := range v.MustUintptrSlice() {
carryon := callback(index, val)
if carryon == false {
break
}
}
return v
}
// WhereUintptr uses the specified decider function to select items
// from the []uintptr. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereUintptr(decider func(int, uintptr) bool) *Value {
var selected []uintptr
v.EachUintptr(func(index int, val uintptr) bool {
shouldSelect := decider(index, val)
if shouldSelect == false {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupUintptr uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]uintptr.
func (v *Value) GroupUintptr(grouper func(int, uintptr) string) *Value {
groups := make(map[string][]uintptr)
v.EachUintptr(func(index int, val uintptr) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]uintptr, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceUintptr uses the specified function to replace each uintptrs
// by iterating each item. The data in the returned result will be a
// []uintptr containing the replaced items.
func (v *Value) ReplaceUintptr(replacer func(int, uintptr) uintptr) *Value {
arr := v.MustUintptrSlice()
replaced := make([]uintptr, len(arr))
v.EachUintptr(func(index int, val uintptr) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectUintptr uses the specified collector function to collect a value
// for each of the uintptrs in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectUintptr(collector func(int, uintptr) interface{}) *Value {
arr := v.MustUintptrSlice()
collected := make([]interface{}, len(arr))
v.EachUintptr(func(index int, val uintptr) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Float32 (float32 and []float32)
--------------------------------------------------
*/
// Float32 gets the value as a float32, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Float32(optionalDefault ...float32) float32 {
if s, ok := v.data.(float32); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return 0
}
// MustFloat32 gets the value as a float32.
//
// Panics if the object is not a float32.
func (v *Value) MustFloat32() float32 {
return v.data.(float32)
}
// Float32Slice gets the value as a []float32, returns the optionalDefault
// value or nil if the value is not a []float32.
func (v *Value) Float32Slice(optionalDefault ...[]float32) []float32 {
if s, ok := v.data.([]float32); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustFloat32Slice gets the value as a []float32.
//
// Panics if the object is not a []float32.
func (v *Value) MustFloat32Slice() []float32 {
return v.data.([]float32)
}
// IsFloat32 gets whether the object contained is a float32 or not.
func (v *Value) IsFloat32() bool {
_, ok := v.data.(float32)
return ok
}
// IsFloat32Slice gets whether the object contained is a []float32 or not.
func (v *Value) IsFloat32Slice() bool {
_, ok := v.data.([]float32)
return ok
}
// EachFloat32 calls the specified callback for each object
// in the []float32.
//
// Panics if the object is the wrong type.
func (v *Value) EachFloat32(callback func(int, float32) bool) *Value {
for index, val := range v.MustFloat32Slice() {
carryon := callback(index, val)
if carryon == false {
break
}
}
return v
}
// WhereFloat32 uses the specified decider function to select items
// from the []float32. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereFloat32(decider func(int, float32) bool) *Value {
var selected []float32
v.EachFloat32(func(index int, val float32) bool {
shouldSelect := decider(index, val)
if shouldSelect == false {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupFloat32 uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]float32.
func (v *Value) GroupFloat32(grouper func(int, float32) string) *Value {
groups := make(map[string][]float32)
v.EachFloat32(func(index int, val float32) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]float32, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceFloat32 uses the specified function to replace each float32s
// by iterating each item. The data in the returned result will be a
// []float32 containing the replaced items.
func (v *Value) ReplaceFloat32(replacer func(int, float32) float32) *Value {
arr := v.MustFloat32Slice()
replaced := make([]float32, len(arr))
v.EachFloat32(func(index int, val float32) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectFloat32 uses the specified collector function to collect a value
// for each of the float32s in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectFloat32(collector func(int, float32) interface{}) *Value {
arr := v.MustFloat32Slice()
collected := make([]interface{}, len(arr))
v.EachFloat32(func(index int, val float32) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Float64 (float64 and []float64)
--------------------------------------------------
*/
// Float64 gets the value as a float64, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Float64(optionalDefault ...float64) float64 {
if s, ok := v.data.(float64); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return 0
}
// MustFloat64 gets the value as a float64.
//
// Panics if the object is not a float64.
func (v *Value) MustFloat64() float64 {
return v.data.(float64)
}
// Float64Slice gets the value as a []float64, returns the optionalDefault
// value or nil if the value is not a []float64.
func (v *Value) Float64Slice(optionalDefault ...[]float64) []float64 {
if s, ok := v.data.([]float64); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustFloat64Slice gets the value as a []float64.
//
// Panics if the object is not a []float64.
func (v *Value) MustFloat64Slice() []float64 {
return v.data.([]float64)
}
// IsFloat64 gets whether the object contained is a float64 or not.
func (v *Value) IsFloat64() bool {
_, ok := v.data.(float64)
return ok
}
// IsFloat64Slice gets whether the object contained is a []float64 or not.
func (v *Value) IsFloat64Slice() bool {
_, ok := v.data.([]float64)
return ok
}
// EachFloat64 calls the specified callback for each object
// in the []float64.
//
// Panics if the object is the wrong type.
func (v *Value) EachFloat64(callback func(int, float64) bool) *Value {
for index, val := range v.MustFloat64Slice() {
carryon := callback(index, val)
if carryon == false {
break
}
}
return v
}
// WhereFloat64 uses the specified decider function to select items
// from the []float64. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereFloat64(decider func(int, float64) bool) *Value {
var selected []float64
v.EachFloat64(func(index int, val float64) bool {
shouldSelect := decider(index, val)
if shouldSelect == false {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupFloat64 uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]float64.
func (v *Value) GroupFloat64(grouper func(int, float64) string) *Value {
groups := make(map[string][]float64)
v.EachFloat64(func(index int, val float64) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]float64, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceFloat64 uses the specified function to replace each float64s
// by iterating each item. The data in the returned result will be a
// []float64 containing the replaced items.
func (v *Value) ReplaceFloat64(replacer func(int, float64) float64) *Value {
arr := v.MustFloat64Slice()
replaced := make([]float64, len(arr))
v.EachFloat64(func(index int, val float64) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectFloat64 uses the specified collector function to collect a value
// for each of the float64s in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectFloat64(collector func(int, float64) interface{}) *Value {
arr := v.MustFloat64Slice()
collected := make([]interface{}, len(arr))
v.EachFloat64(func(index int, val float64) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Complex64 (complex64 and []complex64)
--------------------------------------------------
*/
// Complex64 gets the value as a complex64, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Complex64(optionalDefault ...complex64) complex64 {
if s, ok := v.data.(complex64); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return 0
}
// MustComplex64 gets the value as a complex64.
//
// Panics if the object is not a complex64.
func (v *Value) MustComplex64() complex64 {
return v.data.(complex64)
}
// Complex64Slice gets the value as a []complex64, returns the optionalDefault
// value or nil if the value is not a []complex64.
func (v *Value) Complex64Slice(optionalDefault ...[]complex64) []complex64 {
if s, ok := v.data.([]complex64); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustComplex64Slice gets the value as a []complex64.
//
// Panics if the object is not a []complex64.
func (v *Value) MustComplex64Slice() []complex64 {
return v.data.([]complex64)
}
// IsComplex64 gets whether the object contained is a complex64 or not.
func (v *Value) IsComplex64() bool {
_, ok := v.data.(complex64)
return ok
}
// IsComplex64Slice gets whether the object contained is a []complex64 or not.
func (v *Value) IsComplex64Slice() bool {
_, ok := v.data.([]complex64)
return ok
}
// EachComplex64 calls the specified callback for each object
// in the []complex64.
//
// Panics if the object is the wrong type.
func (v *Value) EachComplex64(callback func(int, complex64) bool) *Value {
for index, val := range v.MustComplex64Slice() {
carryon := callback(index, val)
if carryon == false {
break
}
}
return v
}
// WhereComplex64 uses the specified decider function to select items
// from the []complex64. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereComplex64(decider func(int, complex64) bool) *Value {
var selected []complex64
v.EachComplex64(func(index int, val complex64) bool {
shouldSelect := decider(index, val)
if shouldSelect == false {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupComplex64 uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]complex64.
func (v *Value) GroupComplex64(grouper func(int, complex64) string) *Value {
groups := make(map[string][]complex64)
v.EachComplex64(func(index int, val complex64) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]complex64, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceComplex64 uses the specified function to replace each complex64s
// by iterating each item. The data in the returned result will be a
// []complex64 containing the replaced items.
func (v *Value) ReplaceComplex64(replacer func(int, complex64) complex64) *Value {
arr := v.MustComplex64Slice()
replaced := make([]complex64, len(arr))
v.EachComplex64(func(index int, val complex64) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectComplex64 uses the specified collector function to collect a value
// for each of the complex64s in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectComplex64(collector func(int, complex64) interface{}) *Value {
arr := v.MustComplex64Slice()
collected := make([]interface{}, len(arr))
v.EachComplex64(func(index int, val complex64) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
/*
Complex128 (complex128 and []complex128)
--------------------------------------------------
*/
// Complex128 gets the value as a complex128, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) Complex128(optionalDefault ...complex128) complex128 {
if s, ok := v.data.(complex128); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return 0
}
// MustComplex128 gets the value as a complex128.
//
// Panics if the object is not a complex128.
func (v *Value) MustComplex128() complex128 {
return v.data.(complex128)
}
// Complex128Slice gets the value as a []complex128, returns the optionalDefault
// value or nil if the value is not a []complex128.
func (v *Value) Complex128Slice(optionalDefault ...[]complex128) []complex128 {
if s, ok := v.data.([]complex128); ok {
return s
}
if len(optionalDefault) == 1 {
return optionalDefault[0]
}
return nil
}
// MustComplex128Slice gets the value as a []complex128.
//
// Panics if the object is not a []complex128.
func (v *Value) MustComplex128Slice() []complex128 {
return v.data.([]complex128)
}
// IsComplex128 gets whether the object contained is a complex128 or not.
func (v *Value) IsComplex128() bool {
_, ok := v.data.(complex128)
return ok
}
// IsComplex128Slice gets whether the object contained is a []complex128 or not.
func (v *Value) IsComplex128Slice() bool {
_, ok := v.data.([]complex128)
return ok
}
// EachComplex128 calls the specified callback for each object
// in the []complex128.
//
// Panics if the object is the wrong type.
func (v *Value) EachComplex128(callback func(int, complex128) bool) *Value {
for index, val := range v.MustComplex128Slice() {
carryon := callback(index, val)
if carryon == false {
break
}
}
return v
}
// WhereComplex128 uses the specified decider function to select items
// from the []complex128. The object contained in the result will contain
// only the selected items.
func (v *Value) WhereComplex128(decider func(int, complex128) bool) *Value {
var selected []complex128
v.EachComplex128(func(index int, val complex128) bool {
shouldSelect := decider(index, val)
if shouldSelect == false {
selected = append(selected, val)
}
return true
})
return &Value{data: selected}
}
// GroupComplex128 uses the specified grouper function to group the items
// keyed by the return of the grouper. The object contained in the
// result will contain a map[string][]complex128.
func (v *Value) GroupComplex128(grouper func(int, complex128) string) *Value {
groups := make(map[string][]complex128)
v.EachComplex128(func(index int, val complex128) bool {
group := grouper(index, val)
if _, ok := groups[group]; !ok {
groups[group] = make([]complex128, 0)
}
groups[group] = append(groups[group], val)
return true
})
return &Value{data: groups}
}
// ReplaceComplex128 uses the specified function to replace each complex128s
// by iterating each item. The data in the returned result will be a
// []complex128 containing the replaced items.
func (v *Value) ReplaceComplex128(replacer func(int, complex128) complex128) *Value {
arr := v.MustComplex128Slice()
replaced := make([]complex128, len(arr))
v.EachComplex128(func(index int, val complex128) bool {
replaced[index] = replacer(index, val)
return true
})
return &Value{data: replaced}
}
// CollectComplex128 uses the specified collector function to collect a value
// for each of the complex128s in the slice. The data returned will be a
// []interface{}.
func (v *Value) CollectComplex128(collector func(int, complex128) interface{}) *Value {
arr := v.MustComplex128Slice()
collected := make([]interface{}, len(arr))
v.EachComplex128(func(index int, val complex128) bool {
collected[index] = collector(index, val)
return true
})
return &Value{data: collected}
}
golang-objx-0.0~git20150928.0.1a9d0bb/type_specific_codegen_test.go 0000664 0000000 0000000 00000224364 12602230340 0024477 0 ustar 00root root 0000000 0000000 package objx
import (
"fmt"
"github.com/stretchr/testify/assert"
"testing"
)
// ************************************************************
// TESTS
// ************************************************************
func TestInter(t *testing.T) {
val := interface{}("something")
m := map[string]interface{}{"value": val, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").Inter())
assert.Equal(t, val, New(m).Get("value").MustInter())
assert.Equal(t, interface{}(nil), New(m).Get("nothing").Inter())
assert.Equal(t, val, New(m).Get("nothing").Inter("something"))
assert.Panics(t, func() {
New(m).Get("age").MustInter()
})
}
func TestInterSlice(t *testing.T) {
val := interface{}("something")
m := map[string]interface{}{"value": []interface{}{val}, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").InterSlice()[0])
assert.Equal(t, val, New(m).Get("value").MustInterSlice()[0])
assert.Equal(t, []interface{}(nil), New(m).Get("nothing").InterSlice())
assert.Equal(t, val, New(m).Get("nothing").InterSlice([]interface{}{interface{}("something")})[0])
assert.Panics(t, func() {
New(m).Get("nothing").MustInterSlice()
})
}
func TestIsInter(t *testing.T) {
var v *Value
v = &Value{data: interface{}("something")}
assert.True(t, v.IsInter())
v = &Value{data: []interface{}{interface{}("something")}}
assert.True(t, v.IsInterSlice())
}
func TestEachInter(t *testing.T) {
v := &Value{data: []interface{}{interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something")}}
count := 0
replacedVals := make([]interface{}, 0)
assert.Equal(t, v, v.EachInter(func(i int, val interface{}) bool {
count++
replacedVals = append(replacedVals, val)
// abort early
if i == 2 {
return false
}
return true
}))
assert.Equal(t, count, 3)
assert.Equal(t, replacedVals[0], v.MustInterSlice()[0])
assert.Equal(t, replacedVals[1], v.MustInterSlice()[1])
assert.Equal(t, replacedVals[2], v.MustInterSlice()[2])
}
func TestWhereInter(t *testing.T) {
v := &Value{data: []interface{}{interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something")}}
selected := v.WhereInter(func(i int, val interface{}) bool {
return i%2 == 0
}).MustInterSlice()
assert.Equal(t, 3, len(selected))
}
func TestGroupInter(t *testing.T) {
v := &Value{data: []interface{}{interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something")}}
grouped := v.GroupInter(func(i int, val interface{}) string {
return fmt.Sprintf("%v", i%2 == 0)
}).data.(map[string][]interface{})
assert.Equal(t, 2, len(grouped))
assert.Equal(t, 3, len(grouped["true"]))
assert.Equal(t, 3, len(grouped["false"]))
}
func TestReplaceInter(t *testing.T) {
v := &Value{data: []interface{}{interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something")}}
rawArr := v.MustInterSlice()
replaced := v.ReplaceInter(func(index int, val interface{}) interface{} {
if index < len(rawArr)-1 {
return rawArr[index+1]
}
return rawArr[0]
})
replacedArr := replaced.MustInterSlice()
if assert.Equal(t, 6, len(replacedArr)) {
assert.Equal(t, replacedArr[0], rawArr[1])
assert.Equal(t, replacedArr[1], rawArr[2])
assert.Equal(t, replacedArr[2], rawArr[3])
assert.Equal(t, replacedArr[3], rawArr[4])
assert.Equal(t, replacedArr[4], rawArr[5])
assert.Equal(t, replacedArr[5], rawArr[0])
}
}
func TestCollectInter(t *testing.T) {
v := &Value{data: []interface{}{interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something"), interface{}("something")}}
collected := v.CollectInter(func(index int, val interface{}) interface{} {
return index
})
collectedArr := collected.MustInterSlice()
if assert.Equal(t, 6, len(collectedArr)) {
assert.Equal(t, collectedArr[0], 0)
assert.Equal(t, collectedArr[1], 1)
assert.Equal(t, collectedArr[2], 2)
assert.Equal(t, collectedArr[3], 3)
assert.Equal(t, collectedArr[4], 4)
assert.Equal(t, collectedArr[5], 5)
}
}
// ************************************************************
// TESTS
// ************************************************************
func TestMSI(t *testing.T) {
val := map[string]interface{}(map[string]interface{}{"name": "Tyler"})
m := map[string]interface{}{"value": val, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").MSI())
assert.Equal(t, val, New(m).Get("value").MustMSI())
assert.Equal(t, map[string]interface{}(nil), New(m).Get("nothing").MSI())
assert.Equal(t, val, New(m).Get("nothing").MSI(map[string]interface{}{"name": "Tyler"}))
assert.Panics(t, func() {
New(m).Get("age").MustMSI()
})
}
func TestMSISlice(t *testing.T) {
val := map[string]interface{}(map[string]interface{}{"name": "Tyler"})
m := map[string]interface{}{"value": []map[string]interface{}{val}, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").MSISlice()[0])
assert.Equal(t, val, New(m).Get("value").MustMSISlice()[0])
assert.Equal(t, []map[string]interface{}(nil), New(m).Get("nothing").MSISlice())
assert.Equal(t, val, New(m).Get("nothing").MSISlice([]map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"})})[0])
assert.Panics(t, func() {
New(m).Get("nothing").MustMSISlice()
})
}
func TestIsMSI(t *testing.T) {
var v *Value
v = &Value{data: map[string]interface{}(map[string]interface{}{"name": "Tyler"})}
assert.True(t, v.IsMSI())
v = &Value{data: []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"})}}
assert.True(t, v.IsMSISlice())
}
func TestEachMSI(t *testing.T) {
v := &Value{data: []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"})}}
count := 0
replacedVals := make([]map[string]interface{}, 0)
assert.Equal(t, v, v.EachMSI(func(i int, val map[string]interface{}) bool {
count++
replacedVals = append(replacedVals, val)
// abort early
if i == 2 {
return false
}
return true
}))
assert.Equal(t, count, 3)
assert.Equal(t, replacedVals[0], v.MustMSISlice()[0])
assert.Equal(t, replacedVals[1], v.MustMSISlice()[1])
assert.Equal(t, replacedVals[2], v.MustMSISlice()[2])
}
func TestWhereMSI(t *testing.T) {
v := &Value{data: []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"})}}
selected := v.WhereMSI(func(i int, val map[string]interface{}) bool {
return i%2 == 0
}).MustMSISlice()
assert.Equal(t, 3, len(selected))
}
func TestGroupMSI(t *testing.T) {
v := &Value{data: []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"})}}
grouped := v.GroupMSI(func(i int, val map[string]interface{}) string {
return fmt.Sprintf("%v", i%2 == 0)
}).data.(map[string][]map[string]interface{})
assert.Equal(t, 2, len(grouped))
assert.Equal(t, 3, len(grouped["true"]))
assert.Equal(t, 3, len(grouped["false"]))
}
func TestReplaceMSI(t *testing.T) {
v := &Value{data: []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"})}}
rawArr := v.MustMSISlice()
replaced := v.ReplaceMSI(func(index int, val map[string]interface{}) map[string]interface{} {
if index < len(rawArr)-1 {
return rawArr[index+1]
}
return rawArr[0]
})
replacedArr := replaced.MustMSISlice()
if assert.Equal(t, 6, len(replacedArr)) {
assert.Equal(t, replacedArr[0], rawArr[1])
assert.Equal(t, replacedArr[1], rawArr[2])
assert.Equal(t, replacedArr[2], rawArr[3])
assert.Equal(t, replacedArr[3], rawArr[4])
assert.Equal(t, replacedArr[4], rawArr[5])
assert.Equal(t, replacedArr[5], rawArr[0])
}
}
func TestCollectMSI(t *testing.T) {
v := &Value{data: []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"})}}
collected := v.CollectMSI(func(index int, val map[string]interface{}) interface{} {
return index
})
collectedArr := collected.MustInterSlice()
if assert.Equal(t, 6, len(collectedArr)) {
assert.Equal(t, collectedArr[0], 0)
assert.Equal(t, collectedArr[1], 1)
assert.Equal(t, collectedArr[2], 2)
assert.Equal(t, collectedArr[3], 3)
assert.Equal(t, collectedArr[4], 4)
assert.Equal(t, collectedArr[5], 5)
}
}
// ************************************************************
// TESTS
// ************************************************************
func TestObjxMap(t *testing.T) {
val := (Map)(New(1))
m := map[string]interface{}{"value": val, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").ObjxMap())
assert.Equal(t, val, New(m).Get("value").MustObjxMap())
assert.Equal(t, (Map)(New(nil)), New(m).Get("nothing").ObjxMap())
assert.Equal(t, val, New(m).Get("nothing").ObjxMap(New(1)))
assert.Panics(t, func() {
New(m).Get("age").MustObjxMap()
})
}
func TestObjxMapSlice(t *testing.T) {
val := (Map)(New(1))
m := map[string]interface{}{"value": [](Map){val}, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").ObjxMapSlice()[0])
assert.Equal(t, val, New(m).Get("value").MustObjxMapSlice()[0])
assert.Equal(t, [](Map)(nil), New(m).Get("nothing").ObjxMapSlice())
assert.Equal(t, val, New(m).Get("nothing").ObjxMapSlice([](Map){(Map)(New(1))})[0])
assert.Panics(t, func() {
New(m).Get("nothing").MustObjxMapSlice()
})
}
func TestIsObjxMap(t *testing.T) {
var v *Value
v = &Value{data: (Map)(New(1))}
assert.True(t, v.IsObjxMap())
v = &Value{data: [](Map){(Map)(New(1))}}
assert.True(t, v.IsObjxMapSlice())
}
func TestEachObjxMap(t *testing.T) {
v := &Value{data: [](Map){(Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1))}}
count := 0
replacedVals := make([](Map), 0)
assert.Equal(t, v, v.EachObjxMap(func(i int, val Map) bool {
count++
replacedVals = append(replacedVals, val)
// abort early
if i == 2 {
return false
}
return true
}))
assert.Equal(t, count, 3)
assert.Equal(t, replacedVals[0], v.MustObjxMapSlice()[0])
assert.Equal(t, replacedVals[1], v.MustObjxMapSlice()[1])
assert.Equal(t, replacedVals[2], v.MustObjxMapSlice()[2])
}
func TestWhereObjxMap(t *testing.T) {
v := &Value{data: [](Map){(Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1))}}
selected := v.WhereObjxMap(func(i int, val Map) bool {
return i%2 == 0
}).MustObjxMapSlice()
assert.Equal(t, 3, len(selected))
}
func TestGroupObjxMap(t *testing.T) {
v := &Value{data: [](Map){(Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1))}}
grouped := v.GroupObjxMap(func(i int, val Map) string {
return fmt.Sprintf("%v", i%2 == 0)
}).data.(map[string][](Map))
assert.Equal(t, 2, len(grouped))
assert.Equal(t, 3, len(grouped["true"]))
assert.Equal(t, 3, len(grouped["false"]))
}
func TestReplaceObjxMap(t *testing.T) {
v := &Value{data: [](Map){(Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1))}}
rawArr := v.MustObjxMapSlice()
replaced := v.ReplaceObjxMap(func(index int, val Map) Map {
if index < len(rawArr)-1 {
return rawArr[index+1]
}
return rawArr[0]
})
replacedArr := replaced.MustObjxMapSlice()
if assert.Equal(t, 6, len(replacedArr)) {
assert.Equal(t, replacedArr[0], rawArr[1])
assert.Equal(t, replacedArr[1], rawArr[2])
assert.Equal(t, replacedArr[2], rawArr[3])
assert.Equal(t, replacedArr[3], rawArr[4])
assert.Equal(t, replacedArr[4], rawArr[5])
assert.Equal(t, replacedArr[5], rawArr[0])
}
}
func TestCollectObjxMap(t *testing.T) {
v := &Value{data: [](Map){(Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1)), (Map)(New(1))}}
collected := v.CollectObjxMap(func(index int, val Map) interface{} {
return index
})
collectedArr := collected.MustInterSlice()
if assert.Equal(t, 6, len(collectedArr)) {
assert.Equal(t, collectedArr[0], 0)
assert.Equal(t, collectedArr[1], 1)
assert.Equal(t, collectedArr[2], 2)
assert.Equal(t, collectedArr[3], 3)
assert.Equal(t, collectedArr[4], 4)
assert.Equal(t, collectedArr[5], 5)
}
}
// ************************************************************
// TESTS
// ************************************************************
func TestBool(t *testing.T) {
val := bool(true)
m := map[string]interface{}{"value": val, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").Bool())
assert.Equal(t, val, New(m).Get("value").MustBool())
assert.Equal(t, bool(false), New(m).Get("nothing").Bool())
assert.Equal(t, val, New(m).Get("nothing").Bool(true))
assert.Panics(t, func() {
New(m).Get("age").MustBool()
})
}
func TestBoolSlice(t *testing.T) {
val := bool(true)
m := map[string]interface{}{"value": []bool{val}, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").BoolSlice()[0])
assert.Equal(t, val, New(m).Get("value").MustBoolSlice()[0])
assert.Equal(t, []bool(nil), New(m).Get("nothing").BoolSlice())
assert.Equal(t, val, New(m).Get("nothing").BoolSlice([]bool{bool(true)})[0])
assert.Panics(t, func() {
New(m).Get("nothing").MustBoolSlice()
})
}
func TestIsBool(t *testing.T) {
var v *Value
v = &Value{data: bool(true)}
assert.True(t, v.IsBool())
v = &Value{data: []bool{bool(true)}}
assert.True(t, v.IsBoolSlice())
}
func TestEachBool(t *testing.T) {
v := &Value{data: []bool{bool(true), bool(true), bool(true), bool(true), bool(true)}}
count := 0
replacedVals := make([]bool, 0)
assert.Equal(t, v, v.EachBool(func(i int, val bool) bool {
count++
replacedVals = append(replacedVals, val)
// abort early
if i == 2 {
return false
}
return true
}))
assert.Equal(t, count, 3)
assert.Equal(t, replacedVals[0], v.MustBoolSlice()[0])
assert.Equal(t, replacedVals[1], v.MustBoolSlice()[1])
assert.Equal(t, replacedVals[2], v.MustBoolSlice()[2])
}
func TestWhereBool(t *testing.T) {
v := &Value{data: []bool{bool(true), bool(true), bool(true), bool(true), bool(true), bool(true)}}
selected := v.WhereBool(func(i int, val bool) bool {
return i%2 == 0
}).MustBoolSlice()
assert.Equal(t, 3, len(selected))
}
func TestGroupBool(t *testing.T) {
v := &Value{data: []bool{bool(true), bool(true), bool(true), bool(true), bool(true), bool(true)}}
grouped := v.GroupBool(func(i int, val bool) string {
return fmt.Sprintf("%v", i%2 == 0)
}).data.(map[string][]bool)
assert.Equal(t, 2, len(grouped))
assert.Equal(t, 3, len(grouped["true"]))
assert.Equal(t, 3, len(grouped["false"]))
}
func TestReplaceBool(t *testing.T) {
v := &Value{data: []bool{bool(true), bool(true), bool(true), bool(true), bool(true), bool(true)}}
rawArr := v.MustBoolSlice()
replaced := v.ReplaceBool(func(index int, val bool) bool {
if index < len(rawArr)-1 {
return rawArr[index+1]
}
return rawArr[0]
})
replacedArr := replaced.MustBoolSlice()
if assert.Equal(t, 6, len(replacedArr)) {
assert.Equal(t, replacedArr[0], rawArr[1])
assert.Equal(t, replacedArr[1], rawArr[2])
assert.Equal(t, replacedArr[2], rawArr[3])
assert.Equal(t, replacedArr[3], rawArr[4])
assert.Equal(t, replacedArr[4], rawArr[5])
assert.Equal(t, replacedArr[5], rawArr[0])
}
}
func TestCollectBool(t *testing.T) {
v := &Value{data: []bool{bool(true), bool(true), bool(true), bool(true), bool(true), bool(true)}}
collected := v.CollectBool(func(index int, val bool) interface{} {
return index
})
collectedArr := collected.MustInterSlice()
if assert.Equal(t, 6, len(collectedArr)) {
assert.Equal(t, collectedArr[0], 0)
assert.Equal(t, collectedArr[1], 1)
assert.Equal(t, collectedArr[2], 2)
assert.Equal(t, collectedArr[3], 3)
assert.Equal(t, collectedArr[4], 4)
assert.Equal(t, collectedArr[5], 5)
}
}
// ************************************************************
// TESTS
// ************************************************************
func TestStr(t *testing.T) {
val := string("hello")
m := map[string]interface{}{"value": val, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").Str())
assert.Equal(t, val, New(m).Get("value").MustStr())
assert.Equal(t, string(""), New(m).Get("nothing").Str())
assert.Equal(t, val, New(m).Get("nothing").Str("hello"))
assert.Panics(t, func() {
New(m).Get("age").MustStr()
})
}
func TestStrSlice(t *testing.T) {
val := string("hello")
m := map[string]interface{}{"value": []string{val}, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").StrSlice()[0])
assert.Equal(t, val, New(m).Get("value").MustStrSlice()[0])
assert.Equal(t, []string(nil), New(m).Get("nothing").StrSlice())
assert.Equal(t, val, New(m).Get("nothing").StrSlice([]string{string("hello")})[0])
assert.Panics(t, func() {
New(m).Get("nothing").MustStrSlice()
})
}
func TestIsStr(t *testing.T) {
var v *Value
v = &Value{data: string("hello")}
assert.True(t, v.IsStr())
v = &Value{data: []string{string("hello")}}
assert.True(t, v.IsStrSlice())
}
func TestEachStr(t *testing.T) {
v := &Value{data: []string{string("hello"), string("hello"), string("hello"), string("hello"), string("hello")}}
count := 0
replacedVals := make([]string, 0)
assert.Equal(t, v, v.EachStr(func(i int, val string) bool {
count++
replacedVals = append(replacedVals, val)
// abort early
if i == 2 {
return false
}
return true
}))
assert.Equal(t, count, 3)
assert.Equal(t, replacedVals[0], v.MustStrSlice()[0])
assert.Equal(t, replacedVals[1], v.MustStrSlice()[1])
assert.Equal(t, replacedVals[2], v.MustStrSlice()[2])
}
func TestWhereStr(t *testing.T) {
v := &Value{data: []string{string("hello"), string("hello"), string("hello"), string("hello"), string("hello"), string("hello")}}
selected := v.WhereStr(func(i int, val string) bool {
return i%2 == 0
}).MustStrSlice()
assert.Equal(t, 3, len(selected))
}
func TestGroupStr(t *testing.T) {
v := &Value{data: []string{string("hello"), string("hello"), string("hello"), string("hello"), string("hello"), string("hello")}}
grouped := v.GroupStr(func(i int, val string) string {
return fmt.Sprintf("%v", i%2 == 0)
}).data.(map[string][]string)
assert.Equal(t, 2, len(grouped))
assert.Equal(t, 3, len(grouped["true"]))
assert.Equal(t, 3, len(grouped["false"]))
}
func TestReplaceStr(t *testing.T) {
v := &Value{data: []string{string("hello"), string("hello"), string("hello"), string("hello"), string("hello"), string("hello")}}
rawArr := v.MustStrSlice()
replaced := v.ReplaceStr(func(index int, val string) string {
if index < len(rawArr)-1 {
return rawArr[index+1]
}
return rawArr[0]
})
replacedArr := replaced.MustStrSlice()
if assert.Equal(t, 6, len(replacedArr)) {
assert.Equal(t, replacedArr[0], rawArr[1])
assert.Equal(t, replacedArr[1], rawArr[2])
assert.Equal(t, replacedArr[2], rawArr[3])
assert.Equal(t, replacedArr[3], rawArr[4])
assert.Equal(t, replacedArr[4], rawArr[5])
assert.Equal(t, replacedArr[5], rawArr[0])
}
}
func TestCollectStr(t *testing.T) {
v := &Value{data: []string{string("hello"), string("hello"), string("hello"), string("hello"), string("hello"), string("hello")}}
collected := v.CollectStr(func(index int, val string) interface{} {
return index
})
collectedArr := collected.MustInterSlice()
if assert.Equal(t, 6, len(collectedArr)) {
assert.Equal(t, collectedArr[0], 0)
assert.Equal(t, collectedArr[1], 1)
assert.Equal(t, collectedArr[2], 2)
assert.Equal(t, collectedArr[3], 3)
assert.Equal(t, collectedArr[4], 4)
assert.Equal(t, collectedArr[5], 5)
}
}
// ************************************************************
// TESTS
// ************************************************************
func TestInt(t *testing.T) {
val := int(1)
m := map[string]interface{}{"value": val, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").Int())
assert.Equal(t, val, New(m).Get("value").MustInt())
assert.Equal(t, int(0), New(m).Get("nothing").Int())
assert.Equal(t, val, New(m).Get("nothing").Int(1))
assert.Panics(t, func() {
New(m).Get("age").MustInt()
})
}
func TestIntSlice(t *testing.T) {
val := int(1)
m := map[string]interface{}{"value": []int{val}, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").IntSlice()[0])
assert.Equal(t, val, New(m).Get("value").MustIntSlice()[0])
assert.Equal(t, []int(nil), New(m).Get("nothing").IntSlice())
assert.Equal(t, val, New(m).Get("nothing").IntSlice([]int{int(1)})[0])
assert.Panics(t, func() {
New(m).Get("nothing").MustIntSlice()
})
}
func TestIsInt(t *testing.T) {
var v *Value
v = &Value{data: int(1)}
assert.True(t, v.IsInt())
v = &Value{data: []int{int(1)}}
assert.True(t, v.IsIntSlice())
}
func TestEachInt(t *testing.T) {
v := &Value{data: []int{int(1), int(1), int(1), int(1), int(1)}}
count := 0
replacedVals := make([]int, 0)
assert.Equal(t, v, v.EachInt(func(i int, val int) bool {
count++
replacedVals = append(replacedVals, val)
// abort early
if i == 2 {
return false
}
return true
}))
assert.Equal(t, count, 3)
assert.Equal(t, replacedVals[0], v.MustIntSlice()[0])
assert.Equal(t, replacedVals[1], v.MustIntSlice()[1])
assert.Equal(t, replacedVals[2], v.MustIntSlice()[2])
}
func TestWhereInt(t *testing.T) {
v := &Value{data: []int{int(1), int(1), int(1), int(1), int(1), int(1)}}
selected := v.WhereInt(func(i int, val int) bool {
return i%2 == 0
}).MustIntSlice()
assert.Equal(t, 3, len(selected))
}
func TestGroupInt(t *testing.T) {
v := &Value{data: []int{int(1), int(1), int(1), int(1), int(1), int(1)}}
grouped := v.GroupInt(func(i int, val int) string {
return fmt.Sprintf("%v", i%2 == 0)
}).data.(map[string][]int)
assert.Equal(t, 2, len(grouped))
assert.Equal(t, 3, len(grouped["true"]))
assert.Equal(t, 3, len(grouped["false"]))
}
func TestReplaceInt(t *testing.T) {
v := &Value{data: []int{int(1), int(1), int(1), int(1), int(1), int(1)}}
rawArr := v.MustIntSlice()
replaced := v.ReplaceInt(func(index int, val int) int {
if index < len(rawArr)-1 {
return rawArr[index+1]
}
return rawArr[0]
})
replacedArr := replaced.MustIntSlice()
if assert.Equal(t, 6, len(replacedArr)) {
assert.Equal(t, replacedArr[0], rawArr[1])
assert.Equal(t, replacedArr[1], rawArr[2])
assert.Equal(t, replacedArr[2], rawArr[3])
assert.Equal(t, replacedArr[3], rawArr[4])
assert.Equal(t, replacedArr[4], rawArr[5])
assert.Equal(t, replacedArr[5], rawArr[0])
}
}
func TestCollectInt(t *testing.T) {
v := &Value{data: []int{int(1), int(1), int(1), int(1), int(1), int(1)}}
collected := v.CollectInt(func(index int, val int) interface{} {
return index
})
collectedArr := collected.MustInterSlice()
if assert.Equal(t, 6, len(collectedArr)) {
assert.Equal(t, collectedArr[0], 0)
assert.Equal(t, collectedArr[1], 1)
assert.Equal(t, collectedArr[2], 2)
assert.Equal(t, collectedArr[3], 3)
assert.Equal(t, collectedArr[4], 4)
assert.Equal(t, collectedArr[5], 5)
}
}
// ************************************************************
// TESTS
// ************************************************************
func TestInt8(t *testing.T) {
val := int8(1)
m := map[string]interface{}{"value": val, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").Int8())
assert.Equal(t, val, New(m).Get("value").MustInt8())
assert.Equal(t, int8(0), New(m).Get("nothing").Int8())
assert.Equal(t, val, New(m).Get("nothing").Int8(1))
assert.Panics(t, func() {
New(m).Get("age").MustInt8()
})
}
func TestInt8Slice(t *testing.T) {
val := int8(1)
m := map[string]interface{}{"value": []int8{val}, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").Int8Slice()[0])
assert.Equal(t, val, New(m).Get("value").MustInt8Slice()[0])
assert.Equal(t, []int8(nil), New(m).Get("nothing").Int8Slice())
assert.Equal(t, val, New(m).Get("nothing").Int8Slice([]int8{int8(1)})[0])
assert.Panics(t, func() {
New(m).Get("nothing").MustInt8Slice()
})
}
func TestIsInt8(t *testing.T) {
var v *Value
v = &Value{data: int8(1)}
assert.True(t, v.IsInt8())
v = &Value{data: []int8{int8(1)}}
assert.True(t, v.IsInt8Slice())
}
func TestEachInt8(t *testing.T) {
v := &Value{data: []int8{int8(1), int8(1), int8(1), int8(1), int8(1)}}
count := 0
replacedVals := make([]int8, 0)
assert.Equal(t, v, v.EachInt8(func(i int, val int8) bool {
count++
replacedVals = append(replacedVals, val)
// abort early
if i == 2 {
return false
}
return true
}))
assert.Equal(t, count, 3)
assert.Equal(t, replacedVals[0], v.MustInt8Slice()[0])
assert.Equal(t, replacedVals[1], v.MustInt8Slice()[1])
assert.Equal(t, replacedVals[2], v.MustInt8Slice()[2])
}
func TestWhereInt8(t *testing.T) {
v := &Value{data: []int8{int8(1), int8(1), int8(1), int8(1), int8(1), int8(1)}}
selected := v.WhereInt8(func(i int, val int8) bool {
return i%2 == 0
}).MustInt8Slice()
assert.Equal(t, 3, len(selected))
}
func TestGroupInt8(t *testing.T) {
v := &Value{data: []int8{int8(1), int8(1), int8(1), int8(1), int8(1), int8(1)}}
grouped := v.GroupInt8(func(i int, val int8) string {
return fmt.Sprintf("%v", i%2 == 0)
}).data.(map[string][]int8)
assert.Equal(t, 2, len(grouped))
assert.Equal(t, 3, len(grouped["true"]))
assert.Equal(t, 3, len(grouped["false"]))
}
func TestReplaceInt8(t *testing.T) {
v := &Value{data: []int8{int8(1), int8(1), int8(1), int8(1), int8(1), int8(1)}}
rawArr := v.MustInt8Slice()
replaced := v.ReplaceInt8(func(index int, val int8) int8 {
if index < len(rawArr)-1 {
return rawArr[index+1]
}
return rawArr[0]
})
replacedArr := replaced.MustInt8Slice()
if assert.Equal(t, 6, len(replacedArr)) {
assert.Equal(t, replacedArr[0], rawArr[1])
assert.Equal(t, replacedArr[1], rawArr[2])
assert.Equal(t, replacedArr[2], rawArr[3])
assert.Equal(t, replacedArr[3], rawArr[4])
assert.Equal(t, replacedArr[4], rawArr[5])
assert.Equal(t, replacedArr[5], rawArr[0])
}
}
func TestCollectInt8(t *testing.T) {
v := &Value{data: []int8{int8(1), int8(1), int8(1), int8(1), int8(1), int8(1)}}
collected := v.CollectInt8(func(index int, val int8) interface{} {
return index
})
collectedArr := collected.MustInterSlice()
if assert.Equal(t, 6, len(collectedArr)) {
assert.Equal(t, collectedArr[0], 0)
assert.Equal(t, collectedArr[1], 1)
assert.Equal(t, collectedArr[2], 2)
assert.Equal(t, collectedArr[3], 3)
assert.Equal(t, collectedArr[4], 4)
assert.Equal(t, collectedArr[5], 5)
}
}
// ************************************************************
// TESTS
// ************************************************************
func TestInt16(t *testing.T) {
val := int16(1)
m := map[string]interface{}{"value": val, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").Int16())
assert.Equal(t, val, New(m).Get("value").MustInt16())
assert.Equal(t, int16(0), New(m).Get("nothing").Int16())
assert.Equal(t, val, New(m).Get("nothing").Int16(1))
assert.Panics(t, func() {
New(m).Get("age").MustInt16()
})
}
func TestInt16Slice(t *testing.T) {
val := int16(1)
m := map[string]interface{}{"value": []int16{val}, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").Int16Slice()[0])
assert.Equal(t, val, New(m).Get("value").MustInt16Slice()[0])
assert.Equal(t, []int16(nil), New(m).Get("nothing").Int16Slice())
assert.Equal(t, val, New(m).Get("nothing").Int16Slice([]int16{int16(1)})[0])
assert.Panics(t, func() {
New(m).Get("nothing").MustInt16Slice()
})
}
func TestIsInt16(t *testing.T) {
var v *Value
v = &Value{data: int16(1)}
assert.True(t, v.IsInt16())
v = &Value{data: []int16{int16(1)}}
assert.True(t, v.IsInt16Slice())
}
func TestEachInt16(t *testing.T) {
v := &Value{data: []int16{int16(1), int16(1), int16(1), int16(1), int16(1)}}
count := 0
replacedVals := make([]int16, 0)
assert.Equal(t, v, v.EachInt16(func(i int, val int16) bool {
count++
replacedVals = append(replacedVals, val)
// abort early
if i == 2 {
return false
}
return true
}))
assert.Equal(t, count, 3)
assert.Equal(t, replacedVals[0], v.MustInt16Slice()[0])
assert.Equal(t, replacedVals[1], v.MustInt16Slice()[1])
assert.Equal(t, replacedVals[2], v.MustInt16Slice()[2])
}
func TestWhereInt16(t *testing.T) {
v := &Value{data: []int16{int16(1), int16(1), int16(1), int16(1), int16(1), int16(1)}}
selected := v.WhereInt16(func(i int, val int16) bool {
return i%2 == 0
}).MustInt16Slice()
assert.Equal(t, 3, len(selected))
}
func TestGroupInt16(t *testing.T) {
v := &Value{data: []int16{int16(1), int16(1), int16(1), int16(1), int16(1), int16(1)}}
grouped := v.GroupInt16(func(i int, val int16) string {
return fmt.Sprintf("%v", i%2 == 0)
}).data.(map[string][]int16)
assert.Equal(t, 2, len(grouped))
assert.Equal(t, 3, len(grouped["true"]))
assert.Equal(t, 3, len(grouped["false"]))
}
func TestReplaceInt16(t *testing.T) {
v := &Value{data: []int16{int16(1), int16(1), int16(1), int16(1), int16(1), int16(1)}}
rawArr := v.MustInt16Slice()
replaced := v.ReplaceInt16(func(index int, val int16) int16 {
if index < len(rawArr)-1 {
return rawArr[index+1]
}
return rawArr[0]
})
replacedArr := replaced.MustInt16Slice()
if assert.Equal(t, 6, len(replacedArr)) {
assert.Equal(t, replacedArr[0], rawArr[1])
assert.Equal(t, replacedArr[1], rawArr[2])
assert.Equal(t, replacedArr[2], rawArr[3])
assert.Equal(t, replacedArr[3], rawArr[4])
assert.Equal(t, replacedArr[4], rawArr[5])
assert.Equal(t, replacedArr[5], rawArr[0])
}
}
func TestCollectInt16(t *testing.T) {
v := &Value{data: []int16{int16(1), int16(1), int16(1), int16(1), int16(1), int16(1)}}
collected := v.CollectInt16(func(index int, val int16) interface{} {
return index
})
collectedArr := collected.MustInterSlice()
if assert.Equal(t, 6, len(collectedArr)) {
assert.Equal(t, collectedArr[0], 0)
assert.Equal(t, collectedArr[1], 1)
assert.Equal(t, collectedArr[2], 2)
assert.Equal(t, collectedArr[3], 3)
assert.Equal(t, collectedArr[4], 4)
assert.Equal(t, collectedArr[5], 5)
}
}
// ************************************************************
// TESTS
// ************************************************************
func TestInt32(t *testing.T) {
val := int32(1)
m := map[string]interface{}{"value": val, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").Int32())
assert.Equal(t, val, New(m).Get("value").MustInt32())
assert.Equal(t, int32(0), New(m).Get("nothing").Int32())
assert.Equal(t, val, New(m).Get("nothing").Int32(1))
assert.Panics(t, func() {
New(m).Get("age").MustInt32()
})
}
func TestInt32Slice(t *testing.T) {
val := int32(1)
m := map[string]interface{}{"value": []int32{val}, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").Int32Slice()[0])
assert.Equal(t, val, New(m).Get("value").MustInt32Slice()[0])
assert.Equal(t, []int32(nil), New(m).Get("nothing").Int32Slice())
assert.Equal(t, val, New(m).Get("nothing").Int32Slice([]int32{int32(1)})[0])
assert.Panics(t, func() {
New(m).Get("nothing").MustInt32Slice()
})
}
func TestIsInt32(t *testing.T) {
var v *Value
v = &Value{data: int32(1)}
assert.True(t, v.IsInt32())
v = &Value{data: []int32{int32(1)}}
assert.True(t, v.IsInt32Slice())
}
func TestEachInt32(t *testing.T) {
v := &Value{data: []int32{int32(1), int32(1), int32(1), int32(1), int32(1)}}
count := 0
replacedVals := make([]int32, 0)
assert.Equal(t, v, v.EachInt32(func(i int, val int32) bool {
count++
replacedVals = append(replacedVals, val)
// abort early
if i == 2 {
return false
}
return true
}))
assert.Equal(t, count, 3)
assert.Equal(t, replacedVals[0], v.MustInt32Slice()[0])
assert.Equal(t, replacedVals[1], v.MustInt32Slice()[1])
assert.Equal(t, replacedVals[2], v.MustInt32Slice()[2])
}
func TestWhereInt32(t *testing.T) {
v := &Value{data: []int32{int32(1), int32(1), int32(1), int32(1), int32(1), int32(1)}}
selected := v.WhereInt32(func(i int, val int32) bool {
return i%2 == 0
}).MustInt32Slice()
assert.Equal(t, 3, len(selected))
}
func TestGroupInt32(t *testing.T) {
v := &Value{data: []int32{int32(1), int32(1), int32(1), int32(1), int32(1), int32(1)}}
grouped := v.GroupInt32(func(i int, val int32) string {
return fmt.Sprintf("%v", i%2 == 0)
}).data.(map[string][]int32)
assert.Equal(t, 2, len(grouped))
assert.Equal(t, 3, len(grouped["true"]))
assert.Equal(t, 3, len(grouped["false"]))
}
func TestReplaceInt32(t *testing.T) {
v := &Value{data: []int32{int32(1), int32(1), int32(1), int32(1), int32(1), int32(1)}}
rawArr := v.MustInt32Slice()
replaced := v.ReplaceInt32(func(index int, val int32) int32 {
if index < len(rawArr)-1 {
return rawArr[index+1]
}
return rawArr[0]
})
replacedArr := replaced.MustInt32Slice()
if assert.Equal(t, 6, len(replacedArr)) {
assert.Equal(t, replacedArr[0], rawArr[1])
assert.Equal(t, replacedArr[1], rawArr[2])
assert.Equal(t, replacedArr[2], rawArr[3])
assert.Equal(t, replacedArr[3], rawArr[4])
assert.Equal(t, replacedArr[4], rawArr[5])
assert.Equal(t, replacedArr[5], rawArr[0])
}
}
func TestCollectInt32(t *testing.T) {
v := &Value{data: []int32{int32(1), int32(1), int32(1), int32(1), int32(1), int32(1)}}
collected := v.CollectInt32(func(index int, val int32) interface{} {
return index
})
collectedArr := collected.MustInterSlice()
if assert.Equal(t, 6, len(collectedArr)) {
assert.Equal(t, collectedArr[0], 0)
assert.Equal(t, collectedArr[1], 1)
assert.Equal(t, collectedArr[2], 2)
assert.Equal(t, collectedArr[3], 3)
assert.Equal(t, collectedArr[4], 4)
assert.Equal(t, collectedArr[5], 5)
}
}
// ************************************************************
// TESTS
// ************************************************************
func TestInt64(t *testing.T) {
val := int64(1)
m := map[string]interface{}{"value": val, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").Int64())
assert.Equal(t, val, New(m).Get("value").MustInt64())
assert.Equal(t, int64(0), New(m).Get("nothing").Int64())
assert.Equal(t, val, New(m).Get("nothing").Int64(1))
assert.Panics(t, func() {
New(m).Get("age").MustInt64()
})
}
func TestInt64Slice(t *testing.T) {
val := int64(1)
m := map[string]interface{}{"value": []int64{val}, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").Int64Slice()[0])
assert.Equal(t, val, New(m).Get("value").MustInt64Slice()[0])
assert.Equal(t, []int64(nil), New(m).Get("nothing").Int64Slice())
assert.Equal(t, val, New(m).Get("nothing").Int64Slice([]int64{int64(1)})[0])
assert.Panics(t, func() {
New(m).Get("nothing").MustInt64Slice()
})
}
func TestIsInt64(t *testing.T) {
var v *Value
v = &Value{data: int64(1)}
assert.True(t, v.IsInt64())
v = &Value{data: []int64{int64(1)}}
assert.True(t, v.IsInt64Slice())
}
func TestEachInt64(t *testing.T) {
v := &Value{data: []int64{int64(1), int64(1), int64(1), int64(1), int64(1)}}
count := 0
replacedVals := make([]int64, 0)
assert.Equal(t, v, v.EachInt64(func(i int, val int64) bool {
count++
replacedVals = append(replacedVals, val)
// abort early
if i == 2 {
return false
}
return true
}))
assert.Equal(t, count, 3)
assert.Equal(t, replacedVals[0], v.MustInt64Slice()[0])
assert.Equal(t, replacedVals[1], v.MustInt64Slice()[1])
assert.Equal(t, replacedVals[2], v.MustInt64Slice()[2])
}
func TestWhereInt64(t *testing.T) {
v := &Value{data: []int64{int64(1), int64(1), int64(1), int64(1), int64(1), int64(1)}}
selected := v.WhereInt64(func(i int, val int64) bool {
return i%2 == 0
}).MustInt64Slice()
assert.Equal(t, 3, len(selected))
}
func TestGroupInt64(t *testing.T) {
v := &Value{data: []int64{int64(1), int64(1), int64(1), int64(1), int64(1), int64(1)}}
grouped := v.GroupInt64(func(i int, val int64) string {
return fmt.Sprintf("%v", i%2 == 0)
}).data.(map[string][]int64)
assert.Equal(t, 2, len(grouped))
assert.Equal(t, 3, len(grouped["true"]))
assert.Equal(t, 3, len(grouped["false"]))
}
func TestReplaceInt64(t *testing.T) {
v := &Value{data: []int64{int64(1), int64(1), int64(1), int64(1), int64(1), int64(1)}}
rawArr := v.MustInt64Slice()
replaced := v.ReplaceInt64(func(index int, val int64) int64 {
if index < len(rawArr)-1 {
return rawArr[index+1]
}
return rawArr[0]
})
replacedArr := replaced.MustInt64Slice()
if assert.Equal(t, 6, len(replacedArr)) {
assert.Equal(t, replacedArr[0], rawArr[1])
assert.Equal(t, replacedArr[1], rawArr[2])
assert.Equal(t, replacedArr[2], rawArr[3])
assert.Equal(t, replacedArr[3], rawArr[4])
assert.Equal(t, replacedArr[4], rawArr[5])
assert.Equal(t, replacedArr[5], rawArr[0])
}
}
func TestCollectInt64(t *testing.T) {
v := &Value{data: []int64{int64(1), int64(1), int64(1), int64(1), int64(1), int64(1)}}
collected := v.CollectInt64(func(index int, val int64) interface{} {
return index
})
collectedArr := collected.MustInterSlice()
if assert.Equal(t, 6, len(collectedArr)) {
assert.Equal(t, collectedArr[0], 0)
assert.Equal(t, collectedArr[1], 1)
assert.Equal(t, collectedArr[2], 2)
assert.Equal(t, collectedArr[3], 3)
assert.Equal(t, collectedArr[4], 4)
assert.Equal(t, collectedArr[5], 5)
}
}
// ************************************************************
// TESTS
// ************************************************************
func TestUint(t *testing.T) {
val := uint(1)
m := map[string]interface{}{"value": val, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").Uint())
assert.Equal(t, val, New(m).Get("value").MustUint())
assert.Equal(t, uint(0), New(m).Get("nothing").Uint())
assert.Equal(t, val, New(m).Get("nothing").Uint(1))
assert.Panics(t, func() {
New(m).Get("age").MustUint()
})
}
func TestUintSlice(t *testing.T) {
val := uint(1)
m := map[string]interface{}{"value": []uint{val}, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").UintSlice()[0])
assert.Equal(t, val, New(m).Get("value").MustUintSlice()[0])
assert.Equal(t, []uint(nil), New(m).Get("nothing").UintSlice())
assert.Equal(t, val, New(m).Get("nothing").UintSlice([]uint{uint(1)})[0])
assert.Panics(t, func() {
New(m).Get("nothing").MustUintSlice()
})
}
func TestIsUint(t *testing.T) {
var v *Value
v = &Value{data: uint(1)}
assert.True(t, v.IsUint())
v = &Value{data: []uint{uint(1)}}
assert.True(t, v.IsUintSlice())
}
func TestEachUint(t *testing.T) {
v := &Value{data: []uint{uint(1), uint(1), uint(1), uint(1), uint(1)}}
count := 0
replacedVals := make([]uint, 0)
assert.Equal(t, v, v.EachUint(func(i int, val uint) bool {
count++
replacedVals = append(replacedVals, val)
// abort early
if i == 2 {
return false
}
return true
}))
assert.Equal(t, count, 3)
assert.Equal(t, replacedVals[0], v.MustUintSlice()[0])
assert.Equal(t, replacedVals[1], v.MustUintSlice()[1])
assert.Equal(t, replacedVals[2], v.MustUintSlice()[2])
}
func TestWhereUint(t *testing.T) {
v := &Value{data: []uint{uint(1), uint(1), uint(1), uint(1), uint(1), uint(1)}}
selected := v.WhereUint(func(i int, val uint) bool {
return i%2 == 0
}).MustUintSlice()
assert.Equal(t, 3, len(selected))
}
func TestGroupUint(t *testing.T) {
v := &Value{data: []uint{uint(1), uint(1), uint(1), uint(1), uint(1), uint(1)}}
grouped := v.GroupUint(func(i int, val uint) string {
return fmt.Sprintf("%v", i%2 == 0)
}).data.(map[string][]uint)
assert.Equal(t, 2, len(grouped))
assert.Equal(t, 3, len(grouped["true"]))
assert.Equal(t, 3, len(grouped["false"]))
}
func TestReplaceUint(t *testing.T) {
v := &Value{data: []uint{uint(1), uint(1), uint(1), uint(1), uint(1), uint(1)}}
rawArr := v.MustUintSlice()
replaced := v.ReplaceUint(func(index int, val uint) uint {
if index < len(rawArr)-1 {
return rawArr[index+1]
}
return rawArr[0]
})
replacedArr := replaced.MustUintSlice()
if assert.Equal(t, 6, len(replacedArr)) {
assert.Equal(t, replacedArr[0], rawArr[1])
assert.Equal(t, replacedArr[1], rawArr[2])
assert.Equal(t, replacedArr[2], rawArr[3])
assert.Equal(t, replacedArr[3], rawArr[4])
assert.Equal(t, replacedArr[4], rawArr[5])
assert.Equal(t, replacedArr[5], rawArr[0])
}
}
func TestCollectUint(t *testing.T) {
v := &Value{data: []uint{uint(1), uint(1), uint(1), uint(1), uint(1), uint(1)}}
collected := v.CollectUint(func(index int, val uint) interface{} {
return index
})
collectedArr := collected.MustInterSlice()
if assert.Equal(t, 6, len(collectedArr)) {
assert.Equal(t, collectedArr[0], 0)
assert.Equal(t, collectedArr[1], 1)
assert.Equal(t, collectedArr[2], 2)
assert.Equal(t, collectedArr[3], 3)
assert.Equal(t, collectedArr[4], 4)
assert.Equal(t, collectedArr[5], 5)
}
}
// ************************************************************
// TESTS
// ************************************************************
func TestUint8(t *testing.T) {
val := uint8(1)
m := map[string]interface{}{"value": val, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").Uint8())
assert.Equal(t, val, New(m).Get("value").MustUint8())
assert.Equal(t, uint8(0), New(m).Get("nothing").Uint8())
assert.Equal(t, val, New(m).Get("nothing").Uint8(1))
assert.Panics(t, func() {
New(m).Get("age").MustUint8()
})
}
func TestUint8Slice(t *testing.T) {
val := uint8(1)
m := map[string]interface{}{"value": []uint8{val}, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").Uint8Slice()[0])
assert.Equal(t, val, New(m).Get("value").MustUint8Slice()[0])
assert.Equal(t, []uint8(nil), New(m).Get("nothing").Uint8Slice())
assert.Equal(t, val, New(m).Get("nothing").Uint8Slice([]uint8{uint8(1)})[0])
assert.Panics(t, func() {
New(m).Get("nothing").MustUint8Slice()
})
}
func TestIsUint8(t *testing.T) {
var v *Value
v = &Value{data: uint8(1)}
assert.True(t, v.IsUint8())
v = &Value{data: []uint8{uint8(1)}}
assert.True(t, v.IsUint8Slice())
}
func TestEachUint8(t *testing.T) {
v := &Value{data: []uint8{uint8(1), uint8(1), uint8(1), uint8(1), uint8(1)}}
count := 0
replacedVals := make([]uint8, 0)
assert.Equal(t, v, v.EachUint8(func(i int, val uint8) bool {
count++
replacedVals = append(replacedVals, val)
// abort early
if i == 2 {
return false
}
return true
}))
assert.Equal(t, count, 3)
assert.Equal(t, replacedVals[0], v.MustUint8Slice()[0])
assert.Equal(t, replacedVals[1], v.MustUint8Slice()[1])
assert.Equal(t, replacedVals[2], v.MustUint8Slice()[2])
}
func TestWhereUint8(t *testing.T) {
v := &Value{data: []uint8{uint8(1), uint8(1), uint8(1), uint8(1), uint8(1), uint8(1)}}
selected := v.WhereUint8(func(i int, val uint8) bool {
return i%2 == 0
}).MustUint8Slice()
assert.Equal(t, 3, len(selected))
}
func TestGroupUint8(t *testing.T) {
v := &Value{data: []uint8{uint8(1), uint8(1), uint8(1), uint8(1), uint8(1), uint8(1)}}
grouped := v.GroupUint8(func(i int, val uint8) string {
return fmt.Sprintf("%v", i%2 == 0)
}).data.(map[string][]uint8)
assert.Equal(t, 2, len(grouped))
assert.Equal(t, 3, len(grouped["true"]))
assert.Equal(t, 3, len(grouped["false"]))
}
func TestReplaceUint8(t *testing.T) {
v := &Value{data: []uint8{uint8(1), uint8(1), uint8(1), uint8(1), uint8(1), uint8(1)}}
rawArr := v.MustUint8Slice()
replaced := v.ReplaceUint8(func(index int, val uint8) uint8 {
if index < len(rawArr)-1 {
return rawArr[index+1]
}
return rawArr[0]
})
replacedArr := replaced.MustUint8Slice()
if assert.Equal(t, 6, len(replacedArr)) {
assert.Equal(t, replacedArr[0], rawArr[1])
assert.Equal(t, replacedArr[1], rawArr[2])
assert.Equal(t, replacedArr[2], rawArr[3])
assert.Equal(t, replacedArr[3], rawArr[4])
assert.Equal(t, replacedArr[4], rawArr[5])
assert.Equal(t, replacedArr[5], rawArr[0])
}
}
func TestCollectUint8(t *testing.T) {
v := &Value{data: []uint8{uint8(1), uint8(1), uint8(1), uint8(1), uint8(1), uint8(1)}}
collected := v.CollectUint8(func(index int, val uint8) interface{} {
return index
})
collectedArr := collected.MustInterSlice()
if assert.Equal(t, 6, len(collectedArr)) {
assert.Equal(t, collectedArr[0], 0)
assert.Equal(t, collectedArr[1], 1)
assert.Equal(t, collectedArr[2], 2)
assert.Equal(t, collectedArr[3], 3)
assert.Equal(t, collectedArr[4], 4)
assert.Equal(t, collectedArr[5], 5)
}
}
// ************************************************************
// TESTS
// ************************************************************
func TestUint16(t *testing.T) {
val := uint16(1)
m := map[string]interface{}{"value": val, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").Uint16())
assert.Equal(t, val, New(m).Get("value").MustUint16())
assert.Equal(t, uint16(0), New(m).Get("nothing").Uint16())
assert.Equal(t, val, New(m).Get("nothing").Uint16(1))
assert.Panics(t, func() {
New(m).Get("age").MustUint16()
})
}
func TestUint16Slice(t *testing.T) {
val := uint16(1)
m := map[string]interface{}{"value": []uint16{val}, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").Uint16Slice()[0])
assert.Equal(t, val, New(m).Get("value").MustUint16Slice()[0])
assert.Equal(t, []uint16(nil), New(m).Get("nothing").Uint16Slice())
assert.Equal(t, val, New(m).Get("nothing").Uint16Slice([]uint16{uint16(1)})[0])
assert.Panics(t, func() {
New(m).Get("nothing").MustUint16Slice()
})
}
func TestIsUint16(t *testing.T) {
var v *Value
v = &Value{data: uint16(1)}
assert.True(t, v.IsUint16())
v = &Value{data: []uint16{uint16(1)}}
assert.True(t, v.IsUint16Slice())
}
func TestEachUint16(t *testing.T) {
v := &Value{data: []uint16{uint16(1), uint16(1), uint16(1), uint16(1), uint16(1)}}
count := 0
replacedVals := make([]uint16, 0)
assert.Equal(t, v, v.EachUint16(func(i int, val uint16) bool {
count++
replacedVals = append(replacedVals, val)
// abort early
if i == 2 {
return false
}
return true
}))
assert.Equal(t, count, 3)
assert.Equal(t, replacedVals[0], v.MustUint16Slice()[0])
assert.Equal(t, replacedVals[1], v.MustUint16Slice()[1])
assert.Equal(t, replacedVals[2], v.MustUint16Slice()[2])
}
func TestWhereUint16(t *testing.T) {
v := &Value{data: []uint16{uint16(1), uint16(1), uint16(1), uint16(1), uint16(1), uint16(1)}}
selected := v.WhereUint16(func(i int, val uint16) bool {
return i%2 == 0
}).MustUint16Slice()
assert.Equal(t, 3, len(selected))
}
func TestGroupUint16(t *testing.T) {
v := &Value{data: []uint16{uint16(1), uint16(1), uint16(1), uint16(1), uint16(1), uint16(1)}}
grouped := v.GroupUint16(func(i int, val uint16) string {
return fmt.Sprintf("%v", i%2 == 0)
}).data.(map[string][]uint16)
assert.Equal(t, 2, len(grouped))
assert.Equal(t, 3, len(grouped["true"]))
assert.Equal(t, 3, len(grouped["false"]))
}
func TestReplaceUint16(t *testing.T) {
v := &Value{data: []uint16{uint16(1), uint16(1), uint16(1), uint16(1), uint16(1), uint16(1)}}
rawArr := v.MustUint16Slice()
replaced := v.ReplaceUint16(func(index int, val uint16) uint16 {
if index < len(rawArr)-1 {
return rawArr[index+1]
}
return rawArr[0]
})
replacedArr := replaced.MustUint16Slice()
if assert.Equal(t, 6, len(replacedArr)) {
assert.Equal(t, replacedArr[0], rawArr[1])
assert.Equal(t, replacedArr[1], rawArr[2])
assert.Equal(t, replacedArr[2], rawArr[3])
assert.Equal(t, replacedArr[3], rawArr[4])
assert.Equal(t, replacedArr[4], rawArr[5])
assert.Equal(t, replacedArr[5], rawArr[0])
}
}
func TestCollectUint16(t *testing.T) {
v := &Value{data: []uint16{uint16(1), uint16(1), uint16(1), uint16(1), uint16(1), uint16(1)}}
collected := v.CollectUint16(func(index int, val uint16) interface{} {
return index
})
collectedArr := collected.MustInterSlice()
if assert.Equal(t, 6, len(collectedArr)) {
assert.Equal(t, collectedArr[0], 0)
assert.Equal(t, collectedArr[1], 1)
assert.Equal(t, collectedArr[2], 2)
assert.Equal(t, collectedArr[3], 3)
assert.Equal(t, collectedArr[4], 4)
assert.Equal(t, collectedArr[5], 5)
}
}
// ************************************************************
// TESTS
// ************************************************************
func TestUint32(t *testing.T) {
val := uint32(1)
m := map[string]interface{}{"value": val, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").Uint32())
assert.Equal(t, val, New(m).Get("value").MustUint32())
assert.Equal(t, uint32(0), New(m).Get("nothing").Uint32())
assert.Equal(t, val, New(m).Get("nothing").Uint32(1))
assert.Panics(t, func() {
New(m).Get("age").MustUint32()
})
}
func TestUint32Slice(t *testing.T) {
val := uint32(1)
m := map[string]interface{}{"value": []uint32{val}, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").Uint32Slice()[0])
assert.Equal(t, val, New(m).Get("value").MustUint32Slice()[0])
assert.Equal(t, []uint32(nil), New(m).Get("nothing").Uint32Slice())
assert.Equal(t, val, New(m).Get("nothing").Uint32Slice([]uint32{uint32(1)})[0])
assert.Panics(t, func() {
New(m).Get("nothing").MustUint32Slice()
})
}
func TestIsUint32(t *testing.T) {
var v *Value
v = &Value{data: uint32(1)}
assert.True(t, v.IsUint32())
v = &Value{data: []uint32{uint32(1)}}
assert.True(t, v.IsUint32Slice())
}
func TestEachUint32(t *testing.T) {
v := &Value{data: []uint32{uint32(1), uint32(1), uint32(1), uint32(1), uint32(1)}}
count := 0
replacedVals := make([]uint32, 0)
assert.Equal(t, v, v.EachUint32(func(i int, val uint32) bool {
count++
replacedVals = append(replacedVals, val)
// abort early
if i == 2 {
return false
}
return true
}))
assert.Equal(t, count, 3)
assert.Equal(t, replacedVals[0], v.MustUint32Slice()[0])
assert.Equal(t, replacedVals[1], v.MustUint32Slice()[1])
assert.Equal(t, replacedVals[2], v.MustUint32Slice()[2])
}
func TestWhereUint32(t *testing.T) {
v := &Value{data: []uint32{uint32(1), uint32(1), uint32(1), uint32(1), uint32(1), uint32(1)}}
selected := v.WhereUint32(func(i int, val uint32) bool {
return i%2 == 0
}).MustUint32Slice()
assert.Equal(t, 3, len(selected))
}
func TestGroupUint32(t *testing.T) {
v := &Value{data: []uint32{uint32(1), uint32(1), uint32(1), uint32(1), uint32(1), uint32(1)}}
grouped := v.GroupUint32(func(i int, val uint32) string {
return fmt.Sprintf("%v", i%2 == 0)
}).data.(map[string][]uint32)
assert.Equal(t, 2, len(grouped))
assert.Equal(t, 3, len(grouped["true"]))
assert.Equal(t, 3, len(grouped["false"]))
}
func TestReplaceUint32(t *testing.T) {
v := &Value{data: []uint32{uint32(1), uint32(1), uint32(1), uint32(1), uint32(1), uint32(1)}}
rawArr := v.MustUint32Slice()
replaced := v.ReplaceUint32(func(index int, val uint32) uint32 {
if index < len(rawArr)-1 {
return rawArr[index+1]
}
return rawArr[0]
})
replacedArr := replaced.MustUint32Slice()
if assert.Equal(t, 6, len(replacedArr)) {
assert.Equal(t, replacedArr[0], rawArr[1])
assert.Equal(t, replacedArr[1], rawArr[2])
assert.Equal(t, replacedArr[2], rawArr[3])
assert.Equal(t, replacedArr[3], rawArr[4])
assert.Equal(t, replacedArr[4], rawArr[5])
assert.Equal(t, replacedArr[5], rawArr[0])
}
}
func TestCollectUint32(t *testing.T) {
v := &Value{data: []uint32{uint32(1), uint32(1), uint32(1), uint32(1), uint32(1), uint32(1)}}
collected := v.CollectUint32(func(index int, val uint32) interface{} {
return index
})
collectedArr := collected.MustInterSlice()
if assert.Equal(t, 6, len(collectedArr)) {
assert.Equal(t, collectedArr[0], 0)
assert.Equal(t, collectedArr[1], 1)
assert.Equal(t, collectedArr[2], 2)
assert.Equal(t, collectedArr[3], 3)
assert.Equal(t, collectedArr[4], 4)
assert.Equal(t, collectedArr[5], 5)
}
}
// ************************************************************
// TESTS
// ************************************************************
func TestUint64(t *testing.T) {
val := uint64(1)
m := map[string]interface{}{"value": val, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").Uint64())
assert.Equal(t, val, New(m).Get("value").MustUint64())
assert.Equal(t, uint64(0), New(m).Get("nothing").Uint64())
assert.Equal(t, val, New(m).Get("nothing").Uint64(1))
assert.Panics(t, func() {
New(m).Get("age").MustUint64()
})
}
func TestUint64Slice(t *testing.T) {
val := uint64(1)
m := map[string]interface{}{"value": []uint64{val}, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").Uint64Slice()[0])
assert.Equal(t, val, New(m).Get("value").MustUint64Slice()[0])
assert.Equal(t, []uint64(nil), New(m).Get("nothing").Uint64Slice())
assert.Equal(t, val, New(m).Get("nothing").Uint64Slice([]uint64{uint64(1)})[0])
assert.Panics(t, func() {
New(m).Get("nothing").MustUint64Slice()
})
}
func TestIsUint64(t *testing.T) {
var v *Value
v = &Value{data: uint64(1)}
assert.True(t, v.IsUint64())
v = &Value{data: []uint64{uint64(1)}}
assert.True(t, v.IsUint64Slice())
}
func TestEachUint64(t *testing.T) {
v := &Value{data: []uint64{uint64(1), uint64(1), uint64(1), uint64(1), uint64(1)}}
count := 0
replacedVals := make([]uint64, 0)
assert.Equal(t, v, v.EachUint64(func(i int, val uint64) bool {
count++
replacedVals = append(replacedVals, val)
// abort early
if i == 2 {
return false
}
return true
}))
assert.Equal(t, count, 3)
assert.Equal(t, replacedVals[0], v.MustUint64Slice()[0])
assert.Equal(t, replacedVals[1], v.MustUint64Slice()[1])
assert.Equal(t, replacedVals[2], v.MustUint64Slice()[2])
}
func TestWhereUint64(t *testing.T) {
v := &Value{data: []uint64{uint64(1), uint64(1), uint64(1), uint64(1), uint64(1), uint64(1)}}
selected := v.WhereUint64(func(i int, val uint64) bool {
return i%2 == 0
}).MustUint64Slice()
assert.Equal(t, 3, len(selected))
}
func TestGroupUint64(t *testing.T) {
v := &Value{data: []uint64{uint64(1), uint64(1), uint64(1), uint64(1), uint64(1), uint64(1)}}
grouped := v.GroupUint64(func(i int, val uint64) string {
return fmt.Sprintf("%v", i%2 == 0)
}).data.(map[string][]uint64)
assert.Equal(t, 2, len(grouped))
assert.Equal(t, 3, len(grouped["true"]))
assert.Equal(t, 3, len(grouped["false"]))
}
func TestReplaceUint64(t *testing.T) {
v := &Value{data: []uint64{uint64(1), uint64(1), uint64(1), uint64(1), uint64(1), uint64(1)}}
rawArr := v.MustUint64Slice()
replaced := v.ReplaceUint64(func(index int, val uint64) uint64 {
if index < len(rawArr)-1 {
return rawArr[index+1]
}
return rawArr[0]
})
replacedArr := replaced.MustUint64Slice()
if assert.Equal(t, 6, len(replacedArr)) {
assert.Equal(t, replacedArr[0], rawArr[1])
assert.Equal(t, replacedArr[1], rawArr[2])
assert.Equal(t, replacedArr[2], rawArr[3])
assert.Equal(t, replacedArr[3], rawArr[4])
assert.Equal(t, replacedArr[4], rawArr[5])
assert.Equal(t, replacedArr[5], rawArr[0])
}
}
func TestCollectUint64(t *testing.T) {
v := &Value{data: []uint64{uint64(1), uint64(1), uint64(1), uint64(1), uint64(1), uint64(1)}}
collected := v.CollectUint64(func(index int, val uint64) interface{} {
return index
})
collectedArr := collected.MustInterSlice()
if assert.Equal(t, 6, len(collectedArr)) {
assert.Equal(t, collectedArr[0], 0)
assert.Equal(t, collectedArr[1], 1)
assert.Equal(t, collectedArr[2], 2)
assert.Equal(t, collectedArr[3], 3)
assert.Equal(t, collectedArr[4], 4)
assert.Equal(t, collectedArr[5], 5)
}
}
// ************************************************************
// TESTS
// ************************************************************
func TestUintptr(t *testing.T) {
val := uintptr(1)
m := map[string]interface{}{"value": val, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").Uintptr())
assert.Equal(t, val, New(m).Get("value").MustUintptr())
assert.Equal(t, uintptr(0), New(m).Get("nothing").Uintptr())
assert.Equal(t, val, New(m).Get("nothing").Uintptr(1))
assert.Panics(t, func() {
New(m).Get("age").MustUintptr()
})
}
func TestUintptrSlice(t *testing.T) {
val := uintptr(1)
m := map[string]interface{}{"value": []uintptr{val}, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").UintptrSlice()[0])
assert.Equal(t, val, New(m).Get("value").MustUintptrSlice()[0])
assert.Equal(t, []uintptr(nil), New(m).Get("nothing").UintptrSlice())
assert.Equal(t, val, New(m).Get("nothing").UintptrSlice([]uintptr{uintptr(1)})[0])
assert.Panics(t, func() {
New(m).Get("nothing").MustUintptrSlice()
})
}
func TestIsUintptr(t *testing.T) {
var v *Value
v = &Value{data: uintptr(1)}
assert.True(t, v.IsUintptr())
v = &Value{data: []uintptr{uintptr(1)}}
assert.True(t, v.IsUintptrSlice())
}
func TestEachUintptr(t *testing.T) {
v := &Value{data: []uintptr{uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1)}}
count := 0
replacedVals := make([]uintptr, 0)
assert.Equal(t, v, v.EachUintptr(func(i int, val uintptr) bool {
count++
replacedVals = append(replacedVals, val)
// abort early
if i == 2 {
return false
}
return true
}))
assert.Equal(t, count, 3)
assert.Equal(t, replacedVals[0], v.MustUintptrSlice()[0])
assert.Equal(t, replacedVals[1], v.MustUintptrSlice()[1])
assert.Equal(t, replacedVals[2], v.MustUintptrSlice()[2])
}
func TestWhereUintptr(t *testing.T) {
v := &Value{data: []uintptr{uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1)}}
selected := v.WhereUintptr(func(i int, val uintptr) bool {
return i%2 == 0
}).MustUintptrSlice()
assert.Equal(t, 3, len(selected))
}
func TestGroupUintptr(t *testing.T) {
v := &Value{data: []uintptr{uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1)}}
grouped := v.GroupUintptr(func(i int, val uintptr) string {
return fmt.Sprintf("%v", i%2 == 0)
}).data.(map[string][]uintptr)
assert.Equal(t, 2, len(grouped))
assert.Equal(t, 3, len(grouped["true"]))
assert.Equal(t, 3, len(grouped["false"]))
}
func TestReplaceUintptr(t *testing.T) {
v := &Value{data: []uintptr{uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1)}}
rawArr := v.MustUintptrSlice()
replaced := v.ReplaceUintptr(func(index int, val uintptr) uintptr {
if index < len(rawArr)-1 {
return rawArr[index+1]
}
return rawArr[0]
})
replacedArr := replaced.MustUintptrSlice()
if assert.Equal(t, 6, len(replacedArr)) {
assert.Equal(t, replacedArr[0], rawArr[1])
assert.Equal(t, replacedArr[1], rawArr[2])
assert.Equal(t, replacedArr[2], rawArr[3])
assert.Equal(t, replacedArr[3], rawArr[4])
assert.Equal(t, replacedArr[4], rawArr[5])
assert.Equal(t, replacedArr[5], rawArr[0])
}
}
func TestCollectUintptr(t *testing.T) {
v := &Value{data: []uintptr{uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1), uintptr(1)}}
collected := v.CollectUintptr(func(index int, val uintptr) interface{} {
return index
})
collectedArr := collected.MustInterSlice()
if assert.Equal(t, 6, len(collectedArr)) {
assert.Equal(t, collectedArr[0], 0)
assert.Equal(t, collectedArr[1], 1)
assert.Equal(t, collectedArr[2], 2)
assert.Equal(t, collectedArr[3], 3)
assert.Equal(t, collectedArr[4], 4)
assert.Equal(t, collectedArr[5], 5)
}
}
// ************************************************************
// TESTS
// ************************************************************
func TestFloat32(t *testing.T) {
val := float32(1)
m := map[string]interface{}{"value": val, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").Float32())
assert.Equal(t, val, New(m).Get("value").MustFloat32())
assert.Equal(t, float32(0), New(m).Get("nothing").Float32())
assert.Equal(t, val, New(m).Get("nothing").Float32(1))
assert.Panics(t, func() {
New(m).Get("age").MustFloat32()
})
}
func TestFloat32Slice(t *testing.T) {
val := float32(1)
m := map[string]interface{}{"value": []float32{val}, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").Float32Slice()[0])
assert.Equal(t, val, New(m).Get("value").MustFloat32Slice()[0])
assert.Equal(t, []float32(nil), New(m).Get("nothing").Float32Slice())
assert.Equal(t, val, New(m).Get("nothing").Float32Slice([]float32{float32(1)})[0])
assert.Panics(t, func() {
New(m).Get("nothing").MustFloat32Slice()
})
}
func TestIsFloat32(t *testing.T) {
var v *Value
v = &Value{data: float32(1)}
assert.True(t, v.IsFloat32())
v = &Value{data: []float32{float32(1)}}
assert.True(t, v.IsFloat32Slice())
}
func TestEachFloat32(t *testing.T) {
v := &Value{data: []float32{float32(1), float32(1), float32(1), float32(1), float32(1)}}
count := 0
replacedVals := make([]float32, 0)
assert.Equal(t, v, v.EachFloat32(func(i int, val float32) bool {
count++
replacedVals = append(replacedVals, val)
// abort early
if i == 2 {
return false
}
return true
}))
assert.Equal(t, count, 3)
assert.Equal(t, replacedVals[0], v.MustFloat32Slice()[0])
assert.Equal(t, replacedVals[1], v.MustFloat32Slice()[1])
assert.Equal(t, replacedVals[2], v.MustFloat32Slice()[2])
}
func TestWhereFloat32(t *testing.T) {
v := &Value{data: []float32{float32(1), float32(1), float32(1), float32(1), float32(1), float32(1)}}
selected := v.WhereFloat32(func(i int, val float32) bool {
return i%2 == 0
}).MustFloat32Slice()
assert.Equal(t, 3, len(selected))
}
func TestGroupFloat32(t *testing.T) {
v := &Value{data: []float32{float32(1), float32(1), float32(1), float32(1), float32(1), float32(1)}}
grouped := v.GroupFloat32(func(i int, val float32) string {
return fmt.Sprintf("%v", i%2 == 0)
}).data.(map[string][]float32)
assert.Equal(t, 2, len(grouped))
assert.Equal(t, 3, len(grouped["true"]))
assert.Equal(t, 3, len(grouped["false"]))
}
func TestReplaceFloat32(t *testing.T) {
v := &Value{data: []float32{float32(1), float32(1), float32(1), float32(1), float32(1), float32(1)}}
rawArr := v.MustFloat32Slice()
replaced := v.ReplaceFloat32(func(index int, val float32) float32 {
if index < len(rawArr)-1 {
return rawArr[index+1]
}
return rawArr[0]
})
replacedArr := replaced.MustFloat32Slice()
if assert.Equal(t, 6, len(replacedArr)) {
assert.Equal(t, replacedArr[0], rawArr[1])
assert.Equal(t, replacedArr[1], rawArr[2])
assert.Equal(t, replacedArr[2], rawArr[3])
assert.Equal(t, replacedArr[3], rawArr[4])
assert.Equal(t, replacedArr[4], rawArr[5])
assert.Equal(t, replacedArr[5], rawArr[0])
}
}
func TestCollectFloat32(t *testing.T) {
v := &Value{data: []float32{float32(1), float32(1), float32(1), float32(1), float32(1), float32(1)}}
collected := v.CollectFloat32(func(index int, val float32) interface{} {
return index
})
collectedArr := collected.MustInterSlice()
if assert.Equal(t, 6, len(collectedArr)) {
assert.Equal(t, collectedArr[0], 0)
assert.Equal(t, collectedArr[1], 1)
assert.Equal(t, collectedArr[2], 2)
assert.Equal(t, collectedArr[3], 3)
assert.Equal(t, collectedArr[4], 4)
assert.Equal(t, collectedArr[5], 5)
}
}
// ************************************************************
// TESTS
// ************************************************************
func TestFloat64(t *testing.T) {
val := float64(1)
m := map[string]interface{}{"value": val, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").Float64())
assert.Equal(t, val, New(m).Get("value").MustFloat64())
assert.Equal(t, float64(0), New(m).Get("nothing").Float64())
assert.Equal(t, val, New(m).Get("nothing").Float64(1))
assert.Panics(t, func() {
New(m).Get("age").MustFloat64()
})
}
func TestFloat64Slice(t *testing.T) {
val := float64(1)
m := map[string]interface{}{"value": []float64{val}, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").Float64Slice()[0])
assert.Equal(t, val, New(m).Get("value").MustFloat64Slice()[0])
assert.Equal(t, []float64(nil), New(m).Get("nothing").Float64Slice())
assert.Equal(t, val, New(m).Get("nothing").Float64Slice([]float64{float64(1)})[0])
assert.Panics(t, func() {
New(m).Get("nothing").MustFloat64Slice()
})
}
func TestIsFloat64(t *testing.T) {
var v *Value
v = &Value{data: float64(1)}
assert.True(t, v.IsFloat64())
v = &Value{data: []float64{float64(1)}}
assert.True(t, v.IsFloat64Slice())
}
func TestEachFloat64(t *testing.T) {
v := &Value{data: []float64{float64(1), float64(1), float64(1), float64(1), float64(1)}}
count := 0
replacedVals := make([]float64, 0)
assert.Equal(t, v, v.EachFloat64(func(i int, val float64) bool {
count++
replacedVals = append(replacedVals, val)
// abort early
if i == 2 {
return false
}
return true
}))
assert.Equal(t, count, 3)
assert.Equal(t, replacedVals[0], v.MustFloat64Slice()[0])
assert.Equal(t, replacedVals[1], v.MustFloat64Slice()[1])
assert.Equal(t, replacedVals[2], v.MustFloat64Slice()[2])
}
func TestWhereFloat64(t *testing.T) {
v := &Value{data: []float64{float64(1), float64(1), float64(1), float64(1), float64(1), float64(1)}}
selected := v.WhereFloat64(func(i int, val float64) bool {
return i%2 == 0
}).MustFloat64Slice()
assert.Equal(t, 3, len(selected))
}
func TestGroupFloat64(t *testing.T) {
v := &Value{data: []float64{float64(1), float64(1), float64(1), float64(1), float64(1), float64(1)}}
grouped := v.GroupFloat64(func(i int, val float64) string {
return fmt.Sprintf("%v", i%2 == 0)
}).data.(map[string][]float64)
assert.Equal(t, 2, len(grouped))
assert.Equal(t, 3, len(grouped["true"]))
assert.Equal(t, 3, len(grouped["false"]))
}
func TestReplaceFloat64(t *testing.T) {
v := &Value{data: []float64{float64(1), float64(1), float64(1), float64(1), float64(1), float64(1)}}
rawArr := v.MustFloat64Slice()
replaced := v.ReplaceFloat64(func(index int, val float64) float64 {
if index < len(rawArr)-1 {
return rawArr[index+1]
}
return rawArr[0]
})
replacedArr := replaced.MustFloat64Slice()
if assert.Equal(t, 6, len(replacedArr)) {
assert.Equal(t, replacedArr[0], rawArr[1])
assert.Equal(t, replacedArr[1], rawArr[2])
assert.Equal(t, replacedArr[2], rawArr[3])
assert.Equal(t, replacedArr[3], rawArr[4])
assert.Equal(t, replacedArr[4], rawArr[5])
assert.Equal(t, replacedArr[5], rawArr[0])
}
}
func TestCollectFloat64(t *testing.T) {
v := &Value{data: []float64{float64(1), float64(1), float64(1), float64(1), float64(1), float64(1)}}
collected := v.CollectFloat64(func(index int, val float64) interface{} {
return index
})
collectedArr := collected.MustInterSlice()
if assert.Equal(t, 6, len(collectedArr)) {
assert.Equal(t, collectedArr[0], 0)
assert.Equal(t, collectedArr[1], 1)
assert.Equal(t, collectedArr[2], 2)
assert.Equal(t, collectedArr[3], 3)
assert.Equal(t, collectedArr[4], 4)
assert.Equal(t, collectedArr[5], 5)
}
}
// ************************************************************
// TESTS
// ************************************************************
func TestComplex64(t *testing.T) {
val := complex64(1)
m := map[string]interface{}{"value": val, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").Complex64())
assert.Equal(t, val, New(m).Get("value").MustComplex64())
assert.Equal(t, complex64(0), New(m).Get("nothing").Complex64())
assert.Equal(t, val, New(m).Get("nothing").Complex64(1))
assert.Panics(t, func() {
New(m).Get("age").MustComplex64()
})
}
func TestComplex64Slice(t *testing.T) {
val := complex64(1)
m := map[string]interface{}{"value": []complex64{val}, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").Complex64Slice()[0])
assert.Equal(t, val, New(m).Get("value").MustComplex64Slice()[0])
assert.Equal(t, []complex64(nil), New(m).Get("nothing").Complex64Slice())
assert.Equal(t, val, New(m).Get("nothing").Complex64Slice([]complex64{complex64(1)})[0])
assert.Panics(t, func() {
New(m).Get("nothing").MustComplex64Slice()
})
}
func TestIsComplex64(t *testing.T) {
var v *Value
v = &Value{data: complex64(1)}
assert.True(t, v.IsComplex64())
v = &Value{data: []complex64{complex64(1)}}
assert.True(t, v.IsComplex64Slice())
}
func TestEachComplex64(t *testing.T) {
v := &Value{data: []complex64{complex64(1), complex64(1), complex64(1), complex64(1), complex64(1)}}
count := 0
replacedVals := make([]complex64, 0)
assert.Equal(t, v, v.EachComplex64(func(i int, val complex64) bool {
count++
replacedVals = append(replacedVals, val)
// abort early
if i == 2 {
return false
}
return true
}))
assert.Equal(t, count, 3)
assert.Equal(t, replacedVals[0], v.MustComplex64Slice()[0])
assert.Equal(t, replacedVals[1], v.MustComplex64Slice()[1])
assert.Equal(t, replacedVals[2], v.MustComplex64Slice()[2])
}
func TestWhereComplex64(t *testing.T) {
v := &Value{data: []complex64{complex64(1), complex64(1), complex64(1), complex64(1), complex64(1), complex64(1)}}
selected := v.WhereComplex64(func(i int, val complex64) bool {
return i%2 == 0
}).MustComplex64Slice()
assert.Equal(t, 3, len(selected))
}
func TestGroupComplex64(t *testing.T) {
v := &Value{data: []complex64{complex64(1), complex64(1), complex64(1), complex64(1), complex64(1), complex64(1)}}
grouped := v.GroupComplex64(func(i int, val complex64) string {
return fmt.Sprintf("%v", i%2 == 0)
}).data.(map[string][]complex64)
assert.Equal(t, 2, len(grouped))
assert.Equal(t, 3, len(grouped["true"]))
assert.Equal(t, 3, len(grouped["false"]))
}
func TestReplaceComplex64(t *testing.T) {
v := &Value{data: []complex64{complex64(1), complex64(1), complex64(1), complex64(1), complex64(1), complex64(1)}}
rawArr := v.MustComplex64Slice()
replaced := v.ReplaceComplex64(func(index int, val complex64) complex64 {
if index < len(rawArr)-1 {
return rawArr[index+1]
}
return rawArr[0]
})
replacedArr := replaced.MustComplex64Slice()
if assert.Equal(t, 6, len(replacedArr)) {
assert.Equal(t, replacedArr[0], rawArr[1])
assert.Equal(t, replacedArr[1], rawArr[2])
assert.Equal(t, replacedArr[2], rawArr[3])
assert.Equal(t, replacedArr[3], rawArr[4])
assert.Equal(t, replacedArr[4], rawArr[5])
assert.Equal(t, replacedArr[5], rawArr[0])
}
}
func TestCollectComplex64(t *testing.T) {
v := &Value{data: []complex64{complex64(1), complex64(1), complex64(1), complex64(1), complex64(1), complex64(1)}}
collected := v.CollectComplex64(func(index int, val complex64) interface{} {
return index
})
collectedArr := collected.MustInterSlice()
if assert.Equal(t, 6, len(collectedArr)) {
assert.Equal(t, collectedArr[0], 0)
assert.Equal(t, collectedArr[1], 1)
assert.Equal(t, collectedArr[2], 2)
assert.Equal(t, collectedArr[3], 3)
assert.Equal(t, collectedArr[4], 4)
assert.Equal(t, collectedArr[5], 5)
}
}
// ************************************************************
// TESTS
// ************************************************************
func TestComplex128(t *testing.T) {
val := complex128(1)
m := map[string]interface{}{"value": val, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").Complex128())
assert.Equal(t, val, New(m).Get("value").MustComplex128())
assert.Equal(t, complex128(0), New(m).Get("nothing").Complex128())
assert.Equal(t, val, New(m).Get("nothing").Complex128(1))
assert.Panics(t, func() {
New(m).Get("age").MustComplex128()
})
}
func TestComplex128Slice(t *testing.T) {
val := complex128(1)
m := map[string]interface{}{"value": []complex128{val}, "nothing": nil}
assert.Equal(t, val, New(m).Get("value").Complex128Slice()[0])
assert.Equal(t, val, New(m).Get("value").MustComplex128Slice()[0])
assert.Equal(t, []complex128(nil), New(m).Get("nothing").Complex128Slice())
assert.Equal(t, val, New(m).Get("nothing").Complex128Slice([]complex128{complex128(1)})[0])
assert.Panics(t, func() {
New(m).Get("nothing").MustComplex128Slice()
})
}
func TestIsComplex128(t *testing.T) {
var v *Value
v = &Value{data: complex128(1)}
assert.True(t, v.IsComplex128())
v = &Value{data: []complex128{complex128(1)}}
assert.True(t, v.IsComplex128Slice())
}
func TestEachComplex128(t *testing.T) {
v := &Value{data: []complex128{complex128(1), complex128(1), complex128(1), complex128(1), complex128(1)}}
count := 0
replacedVals := make([]complex128, 0)
assert.Equal(t, v, v.EachComplex128(func(i int, val complex128) bool {
count++
replacedVals = append(replacedVals, val)
// abort early
if i == 2 {
return false
}
return true
}))
assert.Equal(t, count, 3)
assert.Equal(t, replacedVals[0], v.MustComplex128Slice()[0])
assert.Equal(t, replacedVals[1], v.MustComplex128Slice()[1])
assert.Equal(t, replacedVals[2], v.MustComplex128Slice()[2])
}
func TestWhereComplex128(t *testing.T) {
v := &Value{data: []complex128{complex128(1), complex128(1), complex128(1), complex128(1), complex128(1), complex128(1)}}
selected := v.WhereComplex128(func(i int, val complex128) bool {
return i%2 == 0
}).MustComplex128Slice()
assert.Equal(t, 3, len(selected))
}
func TestGroupComplex128(t *testing.T) {
v := &Value{data: []complex128{complex128(1), complex128(1), complex128(1), complex128(1), complex128(1), complex128(1)}}
grouped := v.GroupComplex128(func(i int, val complex128) string {
return fmt.Sprintf("%v", i%2 == 0)
}).data.(map[string][]complex128)
assert.Equal(t, 2, len(grouped))
assert.Equal(t, 3, len(grouped["true"]))
assert.Equal(t, 3, len(grouped["false"]))
}
func TestReplaceComplex128(t *testing.T) {
v := &Value{data: []complex128{complex128(1), complex128(1), complex128(1), complex128(1), complex128(1), complex128(1)}}
rawArr := v.MustComplex128Slice()
replaced := v.ReplaceComplex128(func(index int, val complex128) complex128 {
if index < len(rawArr)-1 {
return rawArr[index+1]
}
return rawArr[0]
})
replacedArr := replaced.MustComplex128Slice()
if assert.Equal(t, 6, len(replacedArr)) {
assert.Equal(t, replacedArr[0], rawArr[1])
assert.Equal(t, replacedArr[1], rawArr[2])
assert.Equal(t, replacedArr[2], rawArr[3])
assert.Equal(t, replacedArr[3], rawArr[4])
assert.Equal(t, replacedArr[4], rawArr[5])
assert.Equal(t, replacedArr[5], rawArr[0])
}
}
func TestCollectComplex128(t *testing.T) {
v := &Value{data: []complex128{complex128(1), complex128(1), complex128(1), complex128(1), complex128(1), complex128(1)}}
collected := v.CollectComplex128(func(index int, val complex128) interface{} {
return index
})
collectedArr := collected.MustInterSlice()
if assert.Equal(t, 6, len(collectedArr)) {
assert.Equal(t, collectedArr[0], 0)
assert.Equal(t, collectedArr[1], 1)
assert.Equal(t, collectedArr[2], 2)
assert.Equal(t, collectedArr[3], 3)
assert.Equal(t, collectedArr[4], 4)
assert.Equal(t, collectedArr[5], 5)
}
}
golang-objx-0.0~git20150928.0.1a9d0bb/value.go 0000664 0000000 0000000 00000002655 12602230340 0020237 0 ustar 00root root 0000000 0000000 package objx
import (
"fmt"
"strconv"
)
// Value provides methods for extracting interface{} data in various
// types.
type Value struct {
// data contains the raw data being managed by this Value
data interface{}
}
// Data returns the raw data contained by this Value
func (v *Value) Data() interface{} {
return v.data
}
// String returns the value always as a string
func (v *Value) String() string {
switch {
case v.IsStr():
return v.Str()
case v.IsBool():
return strconv.FormatBool(v.Bool())
case v.IsFloat32():
return strconv.FormatFloat(float64(v.Float32()), 'f', -1, 32)
case v.IsFloat64():
return strconv.FormatFloat(v.Float64(), 'f', -1, 64)
case v.IsInt():
return strconv.FormatInt(int64(v.Int()), 10)
case v.IsInt():
return strconv.FormatInt(int64(v.Int()), 10)
case v.IsInt8():
return strconv.FormatInt(int64(v.Int8()), 10)
case v.IsInt16():
return strconv.FormatInt(int64(v.Int16()), 10)
case v.IsInt32():
return strconv.FormatInt(int64(v.Int32()), 10)
case v.IsInt64():
return strconv.FormatInt(v.Int64(), 10)
case v.IsUint():
return strconv.FormatUint(uint64(v.Uint()), 10)
case v.IsUint8():
return strconv.FormatUint(uint64(v.Uint8()), 10)
case v.IsUint16():
return strconv.FormatUint(uint64(v.Uint16()), 10)
case v.IsUint32():
return strconv.FormatUint(uint64(v.Uint32()), 10)
case v.IsUint64():
return strconv.FormatUint(v.Uint64(), 10)
}
return fmt.Sprintf("%#v", v.Data())
}
golang-objx-0.0~git20150928.0.1a9d0bb/value_test.go 0000664 0000000 0000000 00000003167 12602230340 0021275 0 ustar 00root root 0000000 0000000 package objx
import (
"github.com/stretchr/testify/assert"
"testing"
)
func TestStringTypeString(t *testing.T) {
m := New(map[string]interface{}{"string": "foo"})
assert.Equal(t, "foo", m.Get("string").String())
}
func TestStringTypeBool(t *testing.T) {
m := New(map[string]interface{}{"bool": true})
assert.Equal(t, "true", m.Get("bool").String())
}
func TestStringTypeInt(t *testing.T) {
m := New(map[string]interface{}{
"int": int(1),
"int8": int8(8),
"int16": int16(16),
"int32": int32(32),
"int64": int64(64),
})
assert.Equal(t, "1", m.Get("int").String())
assert.Equal(t, "8", m.Get("int8").String())
assert.Equal(t, "16", m.Get("int16").String())
assert.Equal(t, "32", m.Get("int32").String())
assert.Equal(t, "64", m.Get("int64").String())
}
func TestStringTypeUint(t *testing.T) {
m := New(map[string]interface{}{
"uint": uint(1),
"uint8": uint8(8),
"uint16": uint16(16),
"uint32": uint32(32),
"uint64": uint64(64),
})
assert.Equal(t, "1", m.Get("uint").String())
assert.Equal(t, "8", m.Get("uint8").String())
assert.Equal(t, "16", m.Get("uint16").String())
assert.Equal(t, "32", m.Get("uint32").String())
assert.Equal(t, "64", m.Get("uint64").String())
}
func TestStringTypeFloat(t *testing.T) {
m := New(map[string]interface{}{
"float32": float32(32.32),
"float64": float64(64.64),
})
assert.Equal(t, "32.32", m.Get("float32").String())
assert.Equal(t, "64.64", m.Get("float64").String())
}
func TestStringTypeOther(t *testing.T) {
m := New(map[string]interface{}{
"other": []string{"foo", "bar"},
})
assert.Equal(t, "[]string{\"foo\", \"bar\"}", m.Get("other").String())
}