| /* |
| {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) |
| } |
| |
| } |
